diff --git a/sprout/checksum/sha1.hpp b/sprout/checksum/sha1.hpp
index c269b5c7..e2f05ba7 100644
--- a/sprout/checksum/sha1.hpp
+++ b/sprout/checksum/sha1.hpp
@@ -158,7 +158,12 @@ namespace sprout {
 					64,
 					bit_count_ + 64 * 8
 					)
-				: sprout::throw_recursive_function_template_instantiation_exeeded()
+				: /*process<D + 1>(
+					h_,
+					sprout::make_array<std::uint8_t>(args...),
+					64,
+					bit_count_ + 64 * 8
+					).template process_block_impl<D + 1>(first, last)*/ sprout::throw_recursive_function_template_instantiation_exeeded()
 				;
 		}
 		template<int D = 16, typename Iterator, typename... Args, SPROUT_RECURSIVE_FUNCTION_TEMPLATE_BREAK(D)>
@@ -175,7 +180,12 @@ namespace sprout {
 					block_byte_index_ + sizeof...(Args),
 					bit_count_ + sizeof...(Args) * 8
 					)
-				: block_byte_index_ + sizeof...(Args) == 64 ? sprout::throw_recursive_function_template_instantiation_exeeded()
+				: block_byte_index_ + sizeof...(Args) == 64 ? /*process<D + 1>(
+					h_,
+					sprout::get_internal(sprout::range::fixed::copy(sprout::make_array<std::uint8_t>(args...), sprout::sub(block_, block_byte_index_))),
+					block_byte_index_ + sizeof...(Args),
+					bit_count_ + sizeof...(Args) * 8
+					).template process_block_impl<D + 1>(first, last)*/ sprout::throw_recursive_function_template_instantiation_exeeded()
 				: process_block_impl<D + 1>(sprout::next(first), last, args..., *first)
 				;
 		}
diff --git a/sprout/compost.hpp b/sprout/compost.hpp
index 684da66c..6d4e63be 100644
--- a/sprout/compost.hpp
+++ b/sprout/compost.hpp
@@ -5,6 +5,7 @@
 #include <sprout/compost/waves.hpp>
 #include <sprout/compost/effects.hpp>
 #include <sprout/compost/formats.hpp>
+#include <sprout/compost/ranges.hpp>
 #include <sprout/compost/sources.hpp>
 
 #endif	// #ifndef SPROUT_COMPOST_HPP
diff --git a/sprout/compost/effects.hpp b/sprout/compost/effects.hpp
index ae9f5323..e6159d3d 100644
--- a/sprout/compost/effects.hpp
+++ b/sprout/compost/effects.hpp
@@ -15,7 +15,5 @@
 #include <sprout/compost/effects/chorus.hpp>
 #include <sprout/compost/effects/noise_gated.hpp>
 #include <sprout/compost/effects/superposed.hpp>
-#include <sprout/compost/effects/jointed.hpp>
-#include <sprout/compost/effects/copied.hpp>
 
 #endif	// #ifndef SPROUT_COMPOST_EFFECTS_HPP
diff --git a/sprout/compost/effects/changed_volume.hpp b/sprout/compost/effects/changed_volume.hpp
index cbefe829..97e74752 100644
--- a/sprout/compost/effects/changed_volume.hpp
+++ b/sprout/compost/effects/changed_volume.hpp
@@ -65,6 +65,8 @@ namespace sprout {
 					;
 			}
 		}	// namespace effects
+
+		using sprout::compost::effects::changed_volume;
 	}	// namespace compost
 }	// namespace sprout
 
diff --git a/sprout/compost/effects/chorus.hpp b/sprout/compost/effects/chorus.hpp
index 7de7f4bf..a0ccc573 100644
--- a/sprout/compost/effects/chorus.hpp
+++ b/sprout/compost/effects/chorus.hpp
@@ -150,6 +150,8 @@ namespace sprout {
 					;
 			}
 		}	// namespace effects
+
+		using sprout::compost::effects::chorus;
 	}	// namespace compost
 }	// namespace sprout
 
diff --git a/sprout/compost/effects/clipped.hpp b/sprout/compost/effects/clipped.hpp
index a66e2fa6..eec8e88e 100644
--- a/sprout/compost/effects/clipped.hpp
+++ b/sprout/compost/effects/clipped.hpp
@@ -79,6 +79,8 @@ namespace sprout {
 					;
 			}
 		}	// namespace effects
+
+		using sprout::compost::effects::clipped;
 	}	// namespace compost
 }	// namespace sprout
 
diff --git a/sprout/compost/effects/compressed.hpp b/sprout/compost/effects/compressed.hpp
index 7621c4e7..99d5ea2a 100644
--- a/sprout/compost/effects/compressed.hpp
+++ b/sprout/compost/effects/compressed.hpp
@@ -120,6 +120,8 @@ namespace sprout {
 					;
 			}
 		}	// namespace effects
+
+		using sprout::compost::effects::compressed;
 	}	// namespace compost
 }	// namespace sprout
 
diff --git a/sprout/compost/effects/copied.hpp b/sprout/compost/effects/copied.hpp
deleted file mode 100644
index ed975a65..00000000
--- a/sprout/compost/effects/copied.hpp
+++ /dev/null
@@ -1,20 +0,0 @@
-#ifndef SPROUT_COMPOST_EFFECTS_COPIED_HPP
-#define SPROUT_COMPOST_EFFECTS_COPIED_HPP
-
-#include <sprout/config.hpp>
-#include <sprout/range/adaptor/copied.hpp>
-
-namespace sprout {
-	namespace compost {
-		namespace effects {
-			//
-			// copied
-			//
-			namespace {
-				SPROUT_STATIC_CONSTEXPR sprout::adaptors::copied_forwarder copied{};
-			}	// anonymous-namespace
-		}	// namespace effects
-	}	// namespace compost
-}	// namespace sprout
-
-#endif	// #ifndef SPROUT_COMPOST_EFFECTS_COPIED_HPP
diff --git a/sprout/compost/effects/distorted.hpp b/sprout/compost/effects/distorted.hpp
index ebe00376..74feaf2f 100644
--- a/sprout/compost/effects/distorted.hpp
+++ b/sprout/compost/effects/distorted.hpp
@@ -72,6 +72,8 @@ namespace sprout {
 					;
 			}
 		}	// namespace effects
+
+		using sprout::compost::effects::distorted;
 	}	// namespace compost
 }	// namespace sprout
 
diff --git a/sprout/compost/effects/fuzzed.hpp b/sprout/compost/effects/fuzzed.hpp
index 94e5feac..f886bb28 100644
--- a/sprout/compost/effects/fuzzed.hpp
+++ b/sprout/compost/effects/fuzzed.hpp
@@ -71,6 +71,8 @@ namespace sprout {
 					;
 			}
 		}	// namespace effects
+
+		using sprout::compost::effects::fuzzed;
 	}	// namespace compost
 }	// namespace sprout
 
diff --git a/sprout/compost/effects/jointed.hpp b/sprout/compost/effects/jointed.hpp
deleted file mode 100644
index 0b43c92a..00000000
--- a/sprout/compost/effects/jointed.hpp
+++ /dev/null
@@ -1,20 +0,0 @@
-#ifndef SPROUT_COMPOST_EFFECTS_JOINTED_HPP
-#define SPROUT_COMPOST_EFFECTS_JOINTED_HPP
-
-#include <sprout/config.hpp>
-#include <sprout/range/adaptor/jointed.hpp>
-
-namespace sprout {
-	namespace compost {
-		namespace effects {
-			//
-			// jointed
-			//
-			namespace {
-				SPROUT_STATIC_CONSTEXPR sprout::adaptors::jointed_forwarder jointed{};
-			}	// anonymous-namespace
-		}	// namespace effects
-	}	// namespace compost
-}	// namespace sprout
-
-#endif	// #ifndef SPROUT_COMPOST_EFFECTS_JOINTED_HPP
diff --git a/sprout/compost/effects/noise_gated.hpp b/sprout/compost/effects/noise_gated.hpp
index 1301f601..7af8aa13 100644
--- a/sprout/compost/effects/noise_gated.hpp
+++ b/sprout/compost/effects/noise_gated.hpp
@@ -110,6 +110,8 @@ namespace sprout {
 					;
 			}
 		}	// namespace effects
+
+		using sprout::compost::effects::noise_gated;
 	}	// namespace compost
 }	// namespace sprout
 
diff --git a/sprout/compost/effects/overdriven.hpp b/sprout/compost/effects/overdriven.hpp
index 9c8963fb..b5674de2 100644
--- a/sprout/compost/effects/overdriven.hpp
+++ b/sprout/compost/effects/overdriven.hpp
@@ -100,6 +100,8 @@ namespace sprout {
 					;
 			}
 		}	// namespace effects
+
+		using sprout::compost::effects::overdriven;
 	}	// namespace compost
 }	// namespace sprout
 
diff --git a/sprout/compost/effects/rectified.hpp b/sprout/compost/effects/rectified.hpp
index 622e6812..7c3a3d6a 100644
--- a/sprout/compost/effects/rectified.hpp
+++ b/sprout/compost/effects/rectified.hpp
@@ -60,6 +60,8 @@ namespace sprout {
 					;
 			}
 		}	// namespace effects
+
+		using sprout::compost::effects::rectified;
 	}	// namespace compost
 }	// namespace sprout
 
diff --git a/sprout/compost/effects/reverbed.hpp b/sprout/compost/effects/reverbed.hpp
index 256137d5..0d8b6de0 100644
--- a/sprout/compost/effects/reverbed.hpp
+++ b/sprout/compost/effects/reverbed.hpp
@@ -143,6 +143,8 @@ namespace sprout {
 					;
 			}
 		}	// namespace effects
+
+		using sprout::compost::effects::reverbed;
 	}	// namespace compost
 }	// namespace sprout
 
diff --git a/sprout/compost/effects/superposed.hpp b/sprout/compost/effects/superposed.hpp
index e47752be..2eb093c6 100644
--- a/sprout/compost/effects/superposed.hpp
+++ b/sprout/compost/effects/superposed.hpp
@@ -71,6 +71,8 @@ namespace sprout {
 					;
 			}
 		}	// namespace effects
+
+		using sprout::compost::effects::superposed;
 	}	// namespace compost
 }	// namespace sprout
 
diff --git a/sprout/compost/effects/tremolo.hpp b/sprout/compost/effects/tremolo.hpp
index 6449741d..674a9561 100644
--- a/sprout/compost/effects/tremolo.hpp
+++ b/sprout/compost/effects/tremolo.hpp
@@ -111,6 +111,8 @@ namespace sprout {
 					;
 			}
 		}	// namespace effects
+
+		using sprout::compost::effects::tremolo;
 	}	// namespace compost
 }	// namespace sprout
 
diff --git a/sprout/compost/effects/vibrato.hpp b/sprout/compost/effects/vibrato.hpp
index f9e9277c..b60b13bd 100644
--- a/sprout/compost/effects/vibrato.hpp
+++ b/sprout/compost/effects/vibrato.hpp
@@ -149,6 +149,8 @@ namespace sprout {
 					;
 			}
 		}	// namespace effects
+
+		using sprout::compost::effects::vibrato;
 	}	// namespace compost
 }	// namespace sprout
 
diff --git a/sprout/compost/formats/as_pcm_wave.hpp b/sprout/compost/formats/as_pcm_wave.hpp
index 5a9807fb..20b191d6 100644
--- a/sprout/compost/formats/as_pcm_wave.hpp
+++ b/sprout/compost/formats/as_pcm_wave.hpp
@@ -92,6 +92,10 @@ namespace sprout {
 				SPROUT_STATIC_CONSTEXPR sprout::compost::formats::as_pcm_wave_forwarder<std::int16_t> as_pcm_wave16{};
 			}	// anonymous-namespace
 		}	// namespace formats
+
+		using sprout::compost::formats::as_pcm_wave;
+		using sprout::compost::formats::as_pcm_wave8;
+		using sprout::compost::formats::as_pcm_wave16;
 	}	// namespace compost
 }	// namespace sprout
 
diff --git a/sprout/compost/ranges.hpp b/sprout/compost/ranges.hpp
new file mode 100644
index 00000000..3a449dd6
--- /dev/null
+++ b/sprout/compost/ranges.hpp
@@ -0,0 +1,8 @@
+#ifndef SPROUT_COMPOST_RANGES_HPP
+#define SPROUT_COMPOST_RANGES_HPP
+
+#include <sprout/config.hpp>
+#include <sprout/compost/ranges/jointed.hpp>
+#include <sprout/compost/ranges/copied.hpp>
+
+#endif	// #ifndef SPROUT_COMPOST_RANGES_HPP
diff --git a/sprout/compost/ranges/copied.hpp b/sprout/compost/ranges/copied.hpp
new file mode 100644
index 00000000..f947f081
--- /dev/null
+++ b/sprout/compost/ranges/copied.hpp
@@ -0,0 +1,20 @@
+#ifndef SPROUT_COMPOST_RANGES_COPIED_HPP
+#define SPROUT_COMPOST_RANGES_COPIED_HPP
+
+#include <sprout/config.hpp>
+#include <sprout/range/adaptor/copied.hpp>
+
+namespace sprout {
+	namespace compost {
+		namespace ranges {
+			//
+			// copied
+			//
+			using sprout::adaptors::copied;
+		}	// namespace ranges
+
+		using sprout::compost::ranges::copied;
+	}	// namespace compost
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_COMPOST_RANGES_COPIED_HPP
diff --git a/sprout/compost/ranges/jointed.hpp b/sprout/compost/ranges/jointed.hpp
new file mode 100644
index 00000000..d8518e37
--- /dev/null
+++ b/sprout/compost/ranges/jointed.hpp
@@ -0,0 +1,20 @@
+#ifndef SPROUT_COMPOST_RANGES_JOINTED_HPP
+#define SPROUT_COMPOST_RANGES_JOINTED_HPP
+
+#include <sprout/config.hpp>
+#include <sprout/range/adaptor/jointed.hpp>
+
+namespace sprout {
+	namespace compost {
+		namespace ranges {
+			//
+			// jointed
+			//
+			using sprout::adaptors::jointed;
+		}	// namespace ranges
+
+		using sprout::compost::ranges::jointed;
+	}	// namespace compost
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_COMPOST_RANGES_JOINTED_HPP
diff --git a/sprout/compost/waves/blanked.hpp b/sprout/compost/waves/blanked.hpp
index 730661bf..68ad2fdb 100644
--- a/sprout/compost/waves/blanked.hpp
+++ b/sprout/compost/waves/blanked.hpp
@@ -32,9 +32,11 @@ namespace sprout {
 			// blanked
 			//
 			namespace {
-			SPROUT_STATIC_CONSTEXPR sprout::compost::waves::blanked_forwarder blanked{};
+				SPROUT_STATIC_CONSTEXPR sprout::compost::waves::blanked_forwarder blanked{};
 			}	// anonymous-namespace
 		}	// namespace waves
+
+		using sprout::compost::waves::blanked;
 	}	// namespace compost
 }	// namespace sprout
 
diff --git a/sprout/compost/waves/sawtooth_wave.hpp b/sprout/compost/waves/sawtooth_wave.hpp
index f3df661d..8f9b530a 100644
--- a/sprout/compost/waves/sawtooth_wave.hpp
+++ b/sprout/compost/waves/sawtooth_wave.hpp
@@ -10,10 +10,10 @@ namespace sprout {
 			//
 			// sawtooth_wave
 			//
-			namespace {
-			SPROUT_STATIC_CONSTEXPR sprout::adaptors::sawtooth_wave_forwarder sawtooth_wave{};
-			}	// anonymous-namespace
+			using sprout::adaptors::sawtooth_wave;
 		}	// namespace waves
+
+		using sprout::compost::waves::sawtooth_wave;
 	}	// namespace compost
 }	// namespace sprout
 
diff --git a/sprout/compost/waves/sinusoidal.hpp b/sprout/compost/waves/sinusoidal.hpp
index 914483aa..f0c28b90 100644
--- a/sprout/compost/waves/sinusoidal.hpp
+++ b/sprout/compost/waves/sinusoidal.hpp
@@ -10,10 +10,10 @@ namespace sprout {
 			//
 			// sinusoidal
 			//
-			namespace {
-				SPROUT_STATIC_CONSTEXPR sprout::adaptors::sinusoidal_forwarder sinusoidal{};
-			}	// anonymous-namespace
+			using sprout::adaptors::sinusoidal;
 		}	// namespace waves
+
+		using sprout::compost::waves::sinusoidal;
 	}	// namespace compost
 }	// namespace sprout
 
diff --git a/sprout/compost/waves/square_wave.hpp b/sprout/compost/waves/square_wave.hpp
index 7cfec18a..6e244d3f 100644
--- a/sprout/compost/waves/square_wave.hpp
+++ b/sprout/compost/waves/square_wave.hpp
@@ -10,10 +10,10 @@ namespace sprout {
 			//
 			// square_wave
 			//
-			namespace {
-				SPROUT_STATIC_CONSTEXPR sprout::adaptors::square_wave_forwarder square_wave{};
-			}	// anonymous-namespace
+			using sprout::adaptors::square_wave;
 		}	// namespace waves
+
+		using sprout::compost::waves::square_wave;
 	}	// namespace compost
 }	// namespace sprout
 
diff --git a/sprout/compost/waves/triangle_wave.hpp b/sprout/compost/waves/triangle_wave.hpp
index 9cc1117a..cd011968 100644
--- a/sprout/compost/waves/triangle_wave.hpp
+++ b/sprout/compost/waves/triangle_wave.hpp
@@ -10,10 +10,10 @@ namespace sprout {
 			//
 			// triangle_wave
 			//
-			namespace {
-				SPROUT_STATIC_CONSTEXPR sprout::adaptors::triangle_wave_forwarder triangle_wave{};
-			}	// anonymous-namespace
+			using sprout::adaptors::triangle_wave;
 		}	// namespace waves
+
+		using sprout::compost::waves::triangle_wave;
 	}	// namespace compost
 }	// namespace sprout
 
diff --git a/sprout/compost/waves/white_noise.hpp b/sprout/compost/waves/white_noise.hpp
index ab59866b..6a98f2b4 100644
--- a/sprout/compost/waves/white_noise.hpp
+++ b/sprout/compost/waves/white_noise.hpp
@@ -146,6 +146,8 @@ namespace sprout {
 					);
 			}
 		}	// namespace waves
+
+		using sprout::compost::waves::white_noise;
 	}	// namespace compost
 
 	//
diff --git a/sprout/iterator/generator_iterator.hpp b/sprout/iterator/generator_iterator.hpp
index 609e4066..98600dd4 100644
--- a/sprout/iterator/generator_iterator.hpp
+++ b/sprout/iterator/generator_iterator.hpp
@@ -2,6 +2,7 @@
 #define SPROUT_ITERATOR_GENERATOR_ITERATOR_HPP
 
 #include <cstddef>
+#include <limits>
 #include <iterator>
 #include <utility>
 #include <stdexcept>
@@ -36,15 +37,13 @@ namespace sprout {
 		difference_type count_;
 	public:
 		SPROUT_CONSTEXPR generator_iterator()
-			: gen_()
-			, count_()
+			: gen_(), count_()
 		{}
 		explicit SPROUT_CONSTEXPR generator_iterator(
 			generator_type const& gen,
-			difference_type count = -1
+			difference_type count = std::numeric_limits<difference_type>::max()
 			)
-			: gen_(gen)
-			, count_(count)
+			: gen_(gen), count_(count)
 		{}
 		generator_type& generator() {
 			return gen_;
diff --git a/sprout/iterator/value_iterator.hpp b/sprout/iterator/value_iterator.hpp
index ced49b45..97801a5a 100644
--- a/sprout/iterator/value_iterator.hpp
+++ b/sprout/iterator/value_iterator.hpp
@@ -2,6 +2,7 @@
 #define SPROUT_ITERATOR_VALUE_ITERATOR_HPP
 
 #include <cstddef>
+#include <limits>
 #include <iterator>
 #include <utility>
 #include <stdexcept>
@@ -52,19 +53,19 @@ namespace sprout {
 		sprout::value_holder<T> holder_;
 		difference_type count_;
 	private:
-		SPROUT_CONSTEXPR value_iterator(sprout::value_holder<T> const& r, std::size_t count)
-			: holder_(r)
-			, count_(count)
+		SPROUT_CONSTEXPR value_iterator(sprout::value_holder<T> const& r, difference_type count)
+			: holder_(r), count_(count)
 		{}
 	public:
 		SPROUT_CONSTEXPR value_iterator()
-			: holder_()
-			, count_()
+			: holder_(), count_()
 		{}
 		value_iterator(value_iterator const&) = default;
-		explicit SPROUT_CONSTEXPR value_iterator(typename sprout::value_holder<T>::param_type p, std::size_t count = -1)
-			: holder_(p)
-			, count_(count)
+		explicit SPROUT_CONSTEXPR value_iterator(
+			typename sprout::value_holder<T>::param_type p,
+			difference_type count = std::numeric_limits<difference_type>::max()
+			)
+			: holder_(p), count_(count)
 		{}
 		operator value_iterator<const_type>() const {
 			return value_iterator<const_type>(holder_.get(), count_);
diff --git a/sprout/random/iterator.hpp b/sprout/random/iterator.hpp
index b8913e7e..968477e7 100644
--- a/sprout/random/iterator.hpp
+++ b/sprout/random/iterator.hpp
@@ -22,7 +22,10 @@ namespace sprout {
 			)
 		-> sprout::generator_iterator<typename std::remove_reference<decltype(distribution(engine))>::type>
 		{
-			return sprout::generator_iterator<typename std::remove_reference<decltype(distribution(engine))>::type>(distribution(engine), count);
+			return count >= 0
+				? sprout::generator_iterator<typename std::remove_reference<decltype(distribution(engine))>::type>(distribution(engine), count)
+				: sprout::generator_iterator<typename std::remove_reference<decltype(distribution(engine))>::type>(distribution(engine))
+				;
 		}
 		template<typename Engine>
 		inline SPROUT_CONSTEXPR auto
@@ -32,7 +35,10 @@ namespace sprout {
 			)
 		-> sprout::generator_iterator<typename std::remove_reference<decltype(engine())>::type>
 		{
-			return sprout::generator_iterator<typename std::remove_reference<decltype(engine())>::type>(engine(), count);
+			return count >= 0
+				? sprout::generator_iterator<typename std::remove_reference<decltype(engine())>::type>(engine(), count)
+				: sprout::generator_iterator<typename std::remove_reference<decltype(engine())>::type>(engine())
+				;
 		}
 
 		//
diff --git a/sprout/range/adaptor.hpp b/sprout/range/adaptor.hpp
index 83bc982c..5c3cb462 100644
--- a/sprout/range/adaptor.hpp
+++ b/sprout/range/adaptor.hpp
@@ -10,6 +10,19 @@
 #include <sprout/range/adaptor/filtered.hpp>
 #include <sprout/range/adaptor/counting.hpp>
 #include <sprout/range/adaptor/outdirected.hpp>
+#include <sprout/range/adaptor/piped.hpp>
+#include <sprout/range/adaptor/taken.hpp>
+#include <sprout/range/adaptor/taken_end.hpp>
+#include <sprout/range/adaptor/dropped.hpp>
+#include <sprout/range/adaptor/dropped_end.hpp>
+#include <sprout/range/adaptor/window.hpp>
+#include <sprout/range/adaptor/offset.hpp>
+#include <sprout/range/adaptor/adapted_taken.hpp>
+#include <sprout/range/adaptor/adapted_taken_end.hpp>
+#include <sprout/range/adaptor/adapted_dropped.hpp>
+#include <sprout/range/adaptor/adapted_dropped_end.hpp>
+#include <sprout/range/adaptor/adapted_window.hpp>
+#include <sprout/range/adaptor/adapted_offset.hpp>
 #include <sprout/range/adaptor/jointed.hpp>
 #include <sprout/range/adaptor/deep_copied.hpp>
 #include <sprout/range/adaptor/indexed.hpp>
diff --git a/sprout/range/adaptor/adapted_dropped.hpp b/sprout/range/adaptor/adapted_dropped.hpp
new file mode 100644
index 00000000..0baa42b9
--- /dev/null
+++ b/sprout/range/adaptor/adapted_dropped.hpp
@@ -0,0 +1,72 @@
+#ifndef SPROUT_RANGE_ADAPTOR_ADAPTED_DROPPED_HPP
+#define SPROUT_RANGE_ADAPTOR_ADAPTED_DROPPED_HPP
+
+#include <sprout/config.hpp>
+#include <sprout/utility/lvalue_forward.hpp>
+#include <sprout/range/adaptor/taken.hpp>
+#include <sprout/range/adaptor/dropped.hpp>
+#include <sprout/range/adaptor/jointed.hpp>
+
+namespace sprout {
+	namespace adaptors {
+		//
+		// adapt_drop_holder
+		//
+		template<typename Adaptor, typename Difference>
+		class adapt_drop_holder {
+		public:
+			typedef Adaptor adaptor_type;
+			typedef Difference difference_type;
+		private:
+			adaptor_type adaptor_;
+			difference_type distance_;
+		public:
+			explicit SPROUT_CONSTEXPR adapt_drop_holder(adaptor_type const& adaptor, difference_type distance)
+				: adaptor_(adaptor), distance_(distance)
+			{}
+			SPROUT_CONSTEXPR adaptor_type const& adaptor() const {
+				return adaptor_;
+			}
+			SPROUT_CONSTEXPR difference_type const& distance() const {
+				return distance_;
+			}
+		};
+
+		//
+		// adapted_dropped_forwarder
+		//
+		class adapted_dropped_forwarder {
+		public:
+			template<typename Adaptor, typename Difference>
+			SPROUT_CONSTEXPR sprout::adaptors::adapt_drop_holder<Adaptor, Difference>
+			operator()(Adaptor const& adaptor, Difference distance) {
+				return sprout::adaptors::adapt_drop_holder<Adaptor, Difference>(adaptor, distance);
+			}
+		};
+
+		//
+		// adapted_dropped
+		//
+		namespace {
+			SPROUT_STATIC_CONSTEXPR sprout::adaptors::adapted_dropped_forwarder adapted_dropped{};
+		}	// anonymous-namespace
+
+		//
+		// operator|
+		//
+		template<typename Range, typename Adaptor, typename Difference>
+		inline SPROUT_CONSTEXPR auto
+		operator|(Range&& lhs, sprout::adaptors::adapt_drop_holder<Adaptor, Difference> const& rhs)
+		-> decltype(
+			sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::taken(rhs.distance())
+				| sprout::adaptors::jointed(sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::dropped(rhs.distance()) | rhs.adaptor())
+			)
+		{
+			return sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::taken(rhs.distance())
+				| sprout::adaptors::jointed(sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::dropped(rhs.distance()) | rhs.adaptor())
+				;
+		}
+	}	// namespace adaptors
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_RANGE_ADAPTOR_ADAPTED_DROPPED_HPP
diff --git a/sprout/range/adaptor/adapted_dropped_end.hpp b/sprout/range/adaptor/adapted_dropped_end.hpp
new file mode 100644
index 00000000..56a90ab0
--- /dev/null
+++ b/sprout/range/adaptor/adapted_dropped_end.hpp
@@ -0,0 +1,72 @@
+#ifndef SPROUT_RANGE_ADAPTOR_ADAPTED_DROPPED_END_HPP
+#define SPROUT_RANGE_ADAPTOR_ADAPTED_DROPPED_END_HPP
+
+#include <sprout/config.hpp>
+#include <sprout/utility/lvalue_forward.hpp>
+#include <sprout/range/adaptor/taken_end.hpp>
+#include <sprout/range/adaptor/dropped_end.hpp>
+#include <sprout/range/adaptor/jointed.hpp>
+
+namespace sprout {
+	namespace adaptors {
+		//
+		// adapt_drop_end_holder
+		//
+		template<typename Adaptor, typename Difference>
+		class adapt_drop_end_holder {
+		public:
+			typedef Adaptor adaptor_type;
+			typedef Difference difference_type;
+		private:
+			adaptor_type adaptor_;
+			difference_type distance_;
+		public:
+			explicit SPROUT_CONSTEXPR adapt_drop_end_holder(adaptor_type const& adaptor, difference_type distance)
+				: adaptor_(adaptor), distance_(distance)
+			{}
+			SPROUT_CONSTEXPR adaptor_type const& adaptor() const {
+				return adaptor_;
+			}
+			SPROUT_CONSTEXPR difference_type const& distance() const {
+				return distance_;
+			}
+		};
+
+		//
+		// adapted_dropped_end_forwarder
+		//
+		class adapted_dropped_end_forwarder {
+		public:
+			template<typename Adaptor, typename Difference>
+			SPROUT_CONSTEXPR sprout::adaptors::adapt_drop_end_holder<Adaptor, Difference>
+			operator()(Adaptor const& adaptor, Difference distance) {
+				return sprout::adaptors::adapt_drop_end_holder<Adaptor, Difference>(adaptor, distance);
+			}
+		};
+
+		//
+		// adapted_dropped_end
+		//
+		namespace {
+			SPROUT_STATIC_CONSTEXPR sprout::adaptors::adapted_dropped_end_forwarder adapted_dropped_end{};
+		}	// anonymous-namespace
+
+		//
+		// operator|
+		//
+		template<typename Range, typename Adaptor, typename Difference>
+		inline SPROUT_CONSTEXPR auto
+		operator|(Range&& lhs, sprout::adaptors::adapt_drop_end_holder<Adaptor, Difference> const& rhs)
+		-> decltype(
+			sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::dropped_end(rhs.distance()) | rhs.adaptor()
+				| sprout::adaptors::jointed(sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::taken_end(rhs.distance()))
+			)
+		{
+			return sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::dropped_end(rhs.distance()) | rhs.adaptor()
+				| sprout::adaptors::jointed(sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::taken_end(rhs.distance()))
+				;
+		}
+	}	// namespace adaptors
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_RANGE_ADAPTOR_ADAPTED_DROPPED_END_HPP
diff --git a/sprout/range/adaptor/adapted_offset.hpp b/sprout/range/adaptor/adapted_offset.hpp
new file mode 100644
index 00000000..af5f39b7
--- /dev/null
+++ b/sprout/range/adaptor/adapted_offset.hpp
@@ -0,0 +1,116 @@
+#ifndef SPROUT_RANGE_ADAPTOR_ADAPTED_OFFSET_HPP
+#define SPROUT_RANGE_ADAPTOR_ADAPTED_OFFSET_HPP
+
+#include <sprout/config.hpp>
+#include <sprout/type_traits/arithmetic_promote.hpp>
+#include <sprout/utility/lvalue_forward.hpp>
+#include <sprout/range/adaptor/taken.hpp>
+#include <sprout/range/adaptor/taken_end.hpp>
+#include <sprout/range/adaptor/offset.hpp>
+#include <sprout/range/adaptor/jointed.hpp>
+
+namespace sprout {
+	namespace adaptors {
+		//
+		// adapt_offset_holder
+		//
+		template<typename Adaptor, typename Difference1, typename Difference2 = void>
+		class adapt_offset_holder {
+		public:
+			typedef Adaptor adaptor_type;
+			typedef typename sprout::arithmetic_promote<Difference1, Difference2>::type difference_type;
+		private:
+			adaptor_type adaptor_;
+			difference_type from_begin_;
+			difference_type from_end_;
+		public:
+			explicit SPROUT_CONSTEXPR adapt_offset_holder(adaptor_type const& adaptor, difference_type from_begin, difference_type from_end)
+				: adaptor_(adaptor), from_begin_(from_begin), from_end_(from_end)
+			{}
+			SPROUT_CONSTEXPR adaptor_type const& adaptor() const {
+				return adaptor_;
+			}
+			SPROUT_CONSTEXPR difference_type const& from_begin() const {
+				return from_begin_;
+			}
+			SPROUT_CONSTEXPR difference_type const& from_end() const {
+				return from_end_;
+			}
+		};
+		template<typename Adaptor, typename Difference>
+		class adapt_offset_holder<Adaptor, Difference, void> {
+		public:
+			typedef Adaptor adaptor_type;
+			typedef Difference difference_type;
+		private:
+			adaptor_type adaptor_;
+			difference_type from_begin_;
+		public:
+			explicit SPROUT_CONSTEXPR adapt_offset_holder(adaptor_type const& adaptor, difference_type from_begin)
+				: adaptor_(adaptor), from_begin_(from_begin)
+			{}
+			SPROUT_CONSTEXPR adaptor_type const& adaptor() const {
+				return adaptor_;
+			}
+			SPROUT_CONSTEXPR difference_type const& from_begin() const {
+				return from_begin_;
+			}
+		};
+
+		//
+		// adapt_offset_forwarder
+		//
+		class adapt_offset_forwarder {
+		public:
+			template<typename Adaptor, typename Difference1, typename Difference2>
+			SPROUT_CONSTEXPR sprout::adaptors::adapt_offset_holder<Adaptor, Difference1, Difference2>
+			operator()(Adaptor const& adaptor, Difference1 from_begin, Difference2 from_end) {
+				return sprout::adaptors::adapt_offset_holder<Adaptor, Difference1, Difference2>(adaptor, from_begin, from_end);
+			}
+			template<typename Adaptor, typename Difference>
+			SPROUT_CONSTEXPR sprout::adaptors::adapt_offset_holder<Adaptor, Difference>
+			operator()(Adaptor const& adaptor, Difference from_begin) {
+				return sprout::adaptors::adapt_offset_holder<Adaptor, Difference>(adaptor, from_begin);
+			}
+		};
+
+		//
+		// adapt_offset
+		//
+		namespace {
+			SPROUT_STATIC_CONSTEXPR sprout::adaptors::adapt_offset_forwarder adapt_offset{};
+		}	// anonymous-namespace
+
+		//
+		// operator|
+		//
+		template<typename Range, typename Adaptor, typename Difference1, typename Difference2>
+		inline SPROUT_CONSTEXPR auto
+		operator|(Range&& lhs, sprout::adaptors::adapt_offset_holder<Adaptor, Difference1, Difference2> const& rhs)
+		-> decltype(
+			sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::taken(rhs.from_begin())
+				| sprout::adaptors::jointed(sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::offset(rhs.from_begin(), rhs.from_end()) | rhs.adaptor())
+				| sprout::adaptors::jointed(sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::taken_end(rhs.from_end()))
+			)
+		{
+			return sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::taken(rhs.from_begin())
+				| sprout::adaptors::jointed(sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::offset(rhs.from_begin(), rhs.from_end()) | rhs.adaptor())
+				| sprout::adaptors::jointed(sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::taken_end(rhs.from_end()))
+				;
+		}
+		template<typename Range, typename Adaptor, typename Difference>
+		inline SPROUT_CONSTEXPR auto
+		operator|(Range&& lhs, sprout::adaptors::adapt_offset_holder<Adaptor, Difference> const& rhs)
+		-> decltype(
+			sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::taken(rhs.from_begin())
+				| sprout::adaptors::jointed(sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::offset(rhs.from_begin()) | rhs.adaptor())
+			)
+		{
+			return sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::taken(rhs.from_begin())
+				| sprout::adaptors::jointed(sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::offset(rhs.from_begin()) | rhs.adaptor())
+				;
+		}
+	}	// namespace adaptors
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_RANGE_ADAPTOR_ADAPTED_OFFSET_HPP
diff --git a/sprout/range/adaptor/adapted_taken.hpp b/sprout/range/adaptor/adapted_taken.hpp
new file mode 100644
index 00000000..1fc85fe1
--- /dev/null
+++ b/sprout/range/adaptor/adapted_taken.hpp
@@ -0,0 +1,72 @@
+#ifndef SPROUT_RANGE_ADAPTOR_ADAPTED_TAKEN_HPP
+#define SPROUT_RANGE_ADAPTOR_ADAPTED_TAKEN_HPP
+
+#include <sprout/config.hpp>
+#include <sprout/utility/lvalue_forward.hpp>
+#include <sprout/range/adaptor/taken.hpp>
+#include <sprout/range/adaptor/dropped.hpp>
+#include <sprout/range/adaptor/jointed.hpp>
+
+namespace sprout {
+	namespace adaptors {
+		//
+		// adapt_take_holder
+		//
+		template<typename Adaptor, typename Difference>
+		class adapt_take_holder {
+		public:
+			typedef Adaptor adaptor_type;
+			typedef Difference difference_type;
+		private:
+			adaptor_type adaptor_;
+			difference_type distance_;
+		public:
+			explicit SPROUT_CONSTEXPR adapt_take_holder(adaptor_type const& adaptor, difference_type distance)
+				: adaptor_(adaptor), distance_(distance)
+			{}
+			SPROUT_CONSTEXPR adaptor_type const& adaptor() const {
+				return adaptor_;
+			}
+			SPROUT_CONSTEXPR difference_type const& distance() const {
+				return distance_;
+			}
+		};
+
+		//
+		// adapted_taken_forwarder
+		//
+		class adapted_taken_forwarder {
+		public:
+			template<typename Adaptor, typename Difference>
+			SPROUT_CONSTEXPR sprout::adaptors::adapt_take_holder<Adaptor, Difference>
+			operator()(Adaptor const& adaptor, Difference distance) {
+				return sprout::adaptors::adapt_take_holder<Adaptor, Difference>(adaptor, distance);
+			}
+		};
+
+		//
+		// adapted_taken
+		//
+		namespace {
+			SPROUT_STATIC_CONSTEXPR sprout::adaptors::adapted_taken_forwarder adapted_taken{};
+		}	// anonymous-namespace
+
+		//
+		// operator|
+		//
+		template<typename Range, typename Adaptor, typename Difference>
+		inline SPROUT_CONSTEXPR auto
+		operator|(Range&& lhs, sprout::adaptors::adapt_take_holder<Adaptor, Difference> const& rhs)
+		-> decltype(
+			sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::taken(rhs.distance()) | rhs.adaptor()
+				| sprout::adaptors::jointed(sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::dropped(rhs.distance()))
+			)
+		{
+			return sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::taken(rhs.distance()) | rhs.adaptor()
+				| sprout::adaptors::jointed(sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::dropped(rhs.distance()))
+				;
+		}
+	}	// namespace adaptors
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_RANGE_ADAPTOR_ADAPTED_TAKEN_HPP
diff --git a/sprout/range/adaptor/adapted_taken_end.hpp b/sprout/range/adaptor/adapted_taken_end.hpp
new file mode 100644
index 00000000..eb609190
--- /dev/null
+++ b/sprout/range/adaptor/adapted_taken_end.hpp
@@ -0,0 +1,72 @@
+#ifndef SPROUT_RANGE_ADAPTOR_ADAPTED_TAKEN_END_HPP
+#define SPROUT_RANGE_ADAPTOR_ADAPTED_TAKEN_END_HPP
+
+#include <sprout/config.hpp>
+#include <sprout/utility/lvalue_forward.hpp>
+#include <sprout/range/adaptor/taken_end.hpp>
+#include <sprout/range/adaptor/dropped_end.hpp>
+#include <sprout/range/adaptor/jointed.hpp>
+
+namespace sprout {
+	namespace adaptors {
+		//
+		// adapt_take_end_holder
+		//
+		template<typename Adaptor, typename Difference>
+		class adapt_take_end_holder {
+		public:
+			typedef Adaptor adaptor_type;
+			typedef Difference difference_type;
+		private:
+			adaptor_type adaptor_;
+			difference_type distance_;
+		public:
+			explicit SPROUT_CONSTEXPR adapt_take_end_holder(adaptor_type const& adaptor, difference_type distance)
+				: adaptor_(adaptor), distance_(distance)
+			{}
+			SPROUT_CONSTEXPR adaptor_type const& adaptor() const {
+				return adaptor_;
+			}
+			SPROUT_CONSTEXPR difference_type const& distance() const {
+				return distance_;
+			}
+		};
+
+		//
+		// adapted_taken_end_forwarder
+		//
+		class adapted_taken_end_forwarder {
+		public:
+			template<typename Adaptor, typename Difference>
+			SPROUT_CONSTEXPR sprout::adaptors::adapt_take_end_holder<Adaptor, Difference>
+			operator()(Adaptor const& adaptor, Difference distance) {
+				return sprout::adaptors::adapt_take_end_holder<Adaptor, Difference>(adaptor, distance);
+			}
+		};
+
+		//
+		// adapted_taken_end
+		//
+		namespace {
+			SPROUT_STATIC_CONSTEXPR sprout::adaptors::adapted_taken_end_forwarder adapted_taken_end{};
+		}	// anonymous-namespace
+
+		//
+		// operator|
+		//
+		template<typename Range, typename Adaptor, typename Difference>
+		inline SPROUT_CONSTEXPR auto
+		operator|(Range&& lhs, sprout::adaptors::adapt_take_end_holder<Adaptor, Difference> const& rhs)
+		-> decltype(
+			sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::dropped_end(rhs.distance())
+				| sprout::adaptors::jointed(sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::taken_end(rhs.distance()) | rhs.adaptor())
+			)
+		{
+			return sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::dropped_end(rhs.distance())
+				| sprout::adaptors::jointed(sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::taken_end(rhs.distance()) | rhs.adaptor())
+				;
+		}
+	}	// namespace adaptors
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_RANGE_ADAPTOR_ADAPTED_TAKEN_END_HPP
diff --git a/sprout/range/adaptor/adapted_window.hpp b/sprout/range/adaptor/adapted_window.hpp
new file mode 100644
index 00000000..d25ef958
--- /dev/null
+++ b/sprout/range/adaptor/adapted_window.hpp
@@ -0,0 +1,116 @@
+#ifndef SPROUT_RANGE_ADAPTOR_ADAPTED_WINDOW_HPP
+#define SPROUT_RANGE_ADAPTOR_ADAPTED_WINDOW_HPP
+
+#include <sprout/config.hpp>
+#include <sprout/type_traits/arithmetic_promote.hpp>
+#include <sprout/utility/lvalue_forward.hpp>
+#include <sprout/range/adaptor/taken.hpp>
+#include <sprout/range/adaptor/dropped.hpp>
+#include <sprout/range/adaptor/window.hpp>
+#include <sprout/range/adaptor/jointed.hpp>
+
+namespace sprout {
+	namespace adaptors {
+		//
+		// adapt_window_holder
+		//
+		template<typename Adaptor, typename Difference1, typename Difference2 = void>
+		class adapt_window_holder {
+		public:
+			typedef Adaptor adaptor_type;
+			typedef typename sprout::arithmetic_promote<Difference1, Difference2>::type difference_type;
+		private:
+			adaptor_type adaptor_;
+			difference_type to_first_;
+			difference_type to_last_;
+		public:
+			explicit SPROUT_CONSTEXPR adapt_window_holder(adaptor_type const& adaptor, difference_type to_first, difference_type to_last)
+				: adaptor_(adaptor), to_first_(to_first), to_last_(to_last)
+			{}
+			SPROUT_CONSTEXPR adaptor_type const& adaptor() const {
+				return adaptor_;
+			}
+			SPROUT_CONSTEXPR difference_type const& to_first() const {
+				return to_first_;
+			}
+			SPROUT_CONSTEXPR difference_type const& to_last() const {
+				return to_last_;
+			}
+		};
+		template<typename Adaptor, typename Difference>
+		class adapt_window_holder<Adaptor, Difference, void> {
+		public:
+			typedef Adaptor adaptor_type;
+			typedef Difference difference_type;
+		private:
+			adaptor_type adaptor_;
+			difference_type to_first_;
+		public:
+			explicit SPROUT_CONSTEXPR adapt_window_holder(adaptor_type const& adaptor, difference_type to_first)
+				: adaptor_(adaptor), to_first_(to_first)
+			{}
+			SPROUT_CONSTEXPR adaptor_type const& adaptor() const {
+				return adaptor_;
+			}
+			SPROUT_CONSTEXPR difference_type const& to_first() const {
+				return to_first_;
+			}
+		};
+
+		//
+		// adapt_window_forwarder
+		//
+		class adapt_window_forwarder {
+		public:
+			template<typename Adaptor, typename Difference1, typename Difference2>
+			SPROUT_CONSTEXPR sprout::adaptors::adapt_window_holder<Adaptor, Difference1, Difference2>
+			operator()(Adaptor const& adaptor, Difference1 to_first, Difference2 to_last) {
+				return sprout::adaptors::adapt_window_holder<Adaptor, Difference1, Difference2>(adaptor, to_first, to_last);
+			}
+			template<typename Adaptor, typename Difference>
+			SPROUT_CONSTEXPR sprout::adaptors::adapt_window_holder<Adaptor, Difference>
+			operator()(Adaptor const& adaptor, Difference to_first) {
+				return sprout::adaptors::adapt_window_holder<Adaptor, Difference>(adaptor, to_first);
+			}
+		};
+
+		//
+		// adapt_window
+		//
+		namespace {
+			SPROUT_STATIC_CONSTEXPR sprout::adaptors::adapt_window_forwarder adapt_window{};
+		}	// anonymous-namespace
+
+		//
+		// operator|
+		//
+		template<typename Range, typename Adaptor, typename Difference1, typename Difference2>
+		inline SPROUT_CONSTEXPR auto
+		operator|(Range&& lhs, sprout::adaptors::adapt_window_holder<Adaptor, Difference1, Difference2> const& rhs)
+		-> decltype(
+			sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::taken(rhs.to_first())
+				| sprout::adaptors::jointed(sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::window(rhs.to_first(), rhs.to_last()) | rhs.adaptor())
+				| sprout::adaptors::jointed(sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::dropped(rhs.to_last()))
+			)
+		{
+			return sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::taken(rhs.to_first())
+				| sprout::adaptors::jointed(sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::window(rhs.to_first(), rhs.to_last()) | rhs.adaptor())
+				| sprout::adaptors::jointed(sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::dropped(rhs.to_last()))
+				;
+		}
+		template<typename Range, typename Adaptor, typename Difference>
+		inline SPROUT_CONSTEXPR auto
+		operator|(Range&& lhs, sprout::adaptors::adapt_window_holder<Adaptor, Difference> const& rhs)
+		-> decltype(
+			sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::taken(rhs.to_first())
+				| sprout::adaptors::jointed(sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::window(rhs.to_first()) | rhs.adaptor())
+			)
+		{
+			return sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::taken(rhs.to_first())
+				| sprout::adaptors::jointed(sprout::lvalue_forward<Range>(lhs) | sprout::adaptors::window(rhs.to_first()) | rhs.adaptor())
+				;
+		}
+	}	// namespace adaptors
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_RANGE_ADAPTOR_ADAPTED_WINDOW_HPP
diff --git a/sprout/range/adaptor/blanked.hpp b/sprout/range/adaptor/blanked.hpp
index 81acdcfb..d1776c53 100644
--- a/sprout/range/adaptor/blanked.hpp
+++ b/sprout/range/adaptor/blanked.hpp
@@ -55,7 +55,7 @@ namespace sprout {
 				difference_type n
 				)
 				: base_type(
-					iterator(value_type(), static_cast<difference_type>(NS_SSCRISK_CEL_OR_SPROUT::min<size_type>(n, sprout::size(range)))),
+					iterator(value_type(), NS_SSCRISK_CEL_OR_SPROUT::min(n, sprout::size(range))),
 					iterator(value_type(), 0)
 					)
 			{}
@@ -65,7 +65,7 @@ namespace sprout {
 				value_type const& value
 				)
 				: base_type(
-					iterator(value, static_cast<difference_type>(NS_SSCRISK_CEL_OR_SPROUT::min<size_type>(n, sprout::size(range)))),
+					iterator(value, NS_SSCRISK_CEL_OR_SPROUT::min(n, sprout::size(range))),
 					iterator(value, 0)
 					)
 			{}
diff --git a/sprout/range/adaptor/dropped.hpp b/sprout/range/adaptor/dropped.hpp
new file mode 100644
index 00000000..6b8dbe8d
--- /dev/null
+++ b/sprout/range/adaptor/dropped.hpp
@@ -0,0 +1,77 @@
+#ifndef SPROUT_RANGE_ADAPTOR_DROPPED_HPP
+#define SPROUT_RANGE_ADAPTOR_DROPPED_HPP
+
+#include <type_traits>
+#include <sprout/config.hpp>
+#include <sprout/container/traits.hpp>
+#include <sprout/container/functions.hpp>
+#include <sprout/iterator/next.hpp>
+#include <sprout/range/range_container.hpp>
+#include <sprout/type_traits/lvalue_reference.hpp>
+#include <sprout/utility/lvalue_forward.hpp>
+#include HDR_ALGORITHM_SSCRISK_CEL_OR_SPROUT
+
+namespace sprout {
+	namespace adaptors {
+		//
+		// drop_holder
+		//
+		template<typename Difference>
+		class drop_holder {
+		public:
+			typedef Difference difference_type;
+		private:
+			difference_type distance_;
+		public:
+			explicit SPROUT_CONSTEXPR drop_holder(difference_type distance)
+				: distance_(distance)
+			{}
+			SPROUT_CONSTEXPR difference_type const& distance() const {
+				return distance_;
+			}
+		};
+
+		//
+		// dropped_forwarder
+		//
+		class dropped_forwarder {
+		public:
+			template<typename Difference>
+			SPROUT_CONSTEXPR sprout::adaptors::drop_holder<Difference>
+			operator()(Difference distance) {
+				return sprout::adaptors::drop_holder<Difference>(distance);
+			}
+		};
+
+		//
+		// dropped
+		//
+		namespace {
+			SPROUT_STATIC_CONSTEXPR sprout::adaptors::dropped_forwarder dropped{};
+		}	// anonymous-namespace
+
+		//
+		// operator|
+		//
+		template<typename Range, typename Difference>
+		inline SPROUT_CONSTEXPR sprout::range::range_container<
+			typename sprout::container_traits<typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type>::iterator
+		>
+		operator|(Range&& lhs, sprout::adaptors::drop_holder<Difference> const& rhs) {
+			typedef typename sprout::container_traits<
+				typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type
+			>::difference_type difference_type;
+			return sprout::range::range_container<
+				typename sprout::container_traits<typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type>::iterator
+			>(
+				sprout::next(
+					sprout::begin(sprout::lvalue_forward<Range>(lhs)),
+					NS_SSCRISK_CEL_OR_SPROUT::min<difference_type>(rhs.distance(), sprout::size(sprout::lvalue_forward<Range>(lhs)))
+					),
+				sprout::end(sprout::lvalue_forward<Range>(lhs))
+				);
+		}
+	}	// namespace adaptors
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_RANGE_ADAPTOR_DROPPED_HPP
diff --git a/sprout/range/adaptor/dropped_end.hpp b/sprout/range/adaptor/dropped_end.hpp
new file mode 100644
index 00000000..aa8f9d13
--- /dev/null
+++ b/sprout/range/adaptor/dropped_end.hpp
@@ -0,0 +1,77 @@
+#ifndef SPROUT_RANGE_ADAPTOR_DROPPED_END_HPP
+#define SPROUT_RANGE_ADAPTOR_DROPPED_END_HPP
+
+#include <type_traits>
+#include <sprout/config.hpp>
+#include <sprout/container/traits.hpp>
+#include <sprout/container/functions.hpp>
+#include <sprout/iterator/next.hpp>
+#include <sprout/range/range_container.hpp>
+#include <sprout/type_traits/lvalue_reference.hpp>
+#include <sprout/utility/lvalue_forward.hpp>
+#include HDR_ALGORITHM_SSCRISK_CEL_OR_SPROUT
+
+namespace sprout {
+	namespace adaptors {
+		//
+		// drop_end_holder
+		//
+		template<typename Difference>
+		class drop_end_holder {
+		public:
+			typedef Difference difference_type;
+		private:
+			difference_type distance_;
+		public:
+			explicit SPROUT_CONSTEXPR drop_end_holder(difference_type distance)
+				: distance_(distance)
+			{}
+			SPROUT_CONSTEXPR difference_type const& distance() const {
+				return distance_;
+			}
+		};
+
+		//
+		// dropped_end_forwarder
+		//
+		class dropped_end_forwarder {
+		public:
+			template<typename Difference>
+			SPROUT_CONSTEXPR sprout::adaptors::drop_end_holder<Difference>
+			operator()(Difference distance) {
+				return sprout::adaptors::drop_end_holder<Difference>(distance);
+			}
+		};
+
+		//
+		// dropped_end
+		//
+		namespace {
+			SPROUT_STATIC_CONSTEXPR sprout::adaptors::dropped_end_forwarder dropped_end{};
+		}	// anonymous-namespace
+
+		//
+		// operator|
+		//
+		template<typename Range, typename Difference>
+		inline SPROUT_CONSTEXPR sprout::range::range_container<
+			typename sprout::container_traits<typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type>::iterator
+		>
+		operator|(Range&& lhs, sprout::adaptors::drop_end_holder<Difference> const& rhs) {
+			typedef typename sprout::container_traits<
+				typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type
+			>::difference_type difference_type;
+			return sprout::range::range_container<
+				typename sprout::container_traits<typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type>::iterator
+			>(
+				sprout::begin(sprout::lvalue_forward<Range>(lhs)),
+				sprout::next(
+					sprout::end(sprout::lvalue_forward<Range>(lhs)),
+					NS_SSCRISK_CEL_OR_SPROUT::max<difference_type>(rhs.distance(), -sprout::size(sprout::lvalue_forward<Range>(lhs)))
+					)
+				);
+		}
+	}	// namespace adaptors
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_RANGE_ADAPTOR_DROPPED_END_HPP
diff --git a/sprout/range/adaptor/offset.hpp b/sprout/range/adaptor/offset.hpp
new file mode 100644
index 00000000..1646b7b0
--- /dev/null
+++ b/sprout/range/adaptor/offset.hpp
@@ -0,0 +1,125 @@
+#ifndef SPROUT_RANGE_ADAPTOR_OFFSET_HPP
+#define SPROUT_RANGE_ADAPTOR_OFFSET_HPP
+
+#include <type_traits>
+#include <sprout/config.hpp>
+#include <sprout/container/traits.hpp>
+#include <sprout/container/functions.hpp>
+#include <sprout/iterator/next.hpp>
+#include <sprout/range/range_container.hpp>
+#include <sprout/type_traits/lvalue_reference.hpp>
+#include <sprout/type_traits/arithmetic_promote.hpp>
+#include <sprout/utility/lvalue_forward.hpp>
+#include HDR_ALGORITHM_SSCRISK_CEL_OR_SPROUT
+
+namespace sprout {
+	namespace adaptors {
+		//
+		// offset_holder
+		//
+		template<typename Difference1, typename Difference2 = void>
+		class offset_holder {
+		public:
+			typedef typename sprout::arithmetic_promote<Difference1, Difference2>::type difference_type;
+		private:
+			difference_type from_begin_;
+			difference_type from_end_;
+		public:
+			SPROUT_CONSTEXPR offset_holder(difference_type from_begin, difference_type from_end)
+				: from_begin_(from_begin), from_end_(from_end)
+			{}
+			SPROUT_CONSTEXPR difference_type const& from_begin() const {
+				return from_begin_;
+			}
+			SPROUT_CONSTEXPR difference_type const& from_end() const {
+				return from_end_;
+			}
+		};
+		template<typename Difference>
+		class offset_holder<Difference, void> {
+		public:
+			typedef Difference difference_type;
+		private:
+			difference_type from_begin_;
+		public:
+			explicit SPROUT_CONSTEXPR offset_holder(difference_type from_begin)
+				: from_begin_(from_begin)
+			{}
+			SPROUT_CONSTEXPR difference_type const& from_begin() const {
+				return from_begin_;
+			}
+		};
+
+		//
+		// offset_forwarder
+		//
+		class offset_forwarder {
+		public:
+			template<typename Difference1, typename Difference2>
+			SPROUT_CONSTEXPR sprout::adaptors::offset_holder<Difference1, Difference2>
+			operator()(Difference1 from_begin, Difference2 from_end) {
+				return sprout::adaptors::offset_holder<Difference1, Difference2>(from_begin, from_end);
+			}
+			template<typename Difference>
+			SPROUT_CONSTEXPR sprout::adaptors::offset_holder<Difference>
+			operator()(Difference from_begin) {
+				return sprout::adaptors::offset_holder<Difference>(from_begin);
+			}
+		};
+
+		//
+		// offset
+		//
+		namespace {
+			SPROUT_STATIC_CONSTEXPR sprout::adaptors::offset_forwarder offset{};
+		}	// anonymous-namespace
+
+		//
+		// operator|
+		//
+		template<typename Range, typename Difference1, typename Difference2>
+		inline SPROUT_CONSTEXPR sprout::range::range_container<
+			typename sprout::container_traits<typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type>::iterator
+		>
+		operator|(Range&& lhs, sprout::adaptors::offset_holder<Difference1, Difference2> const& rhs) {
+			typedef typename sprout::container_traits<
+				typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type
+			>::difference_type difference_type;
+			return sprout::range::range_container<
+				typename sprout::container_traits<typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type>::iterator
+			>(
+				sprout::next(
+					sprout::begin(sprout::lvalue_forward<Range>(lhs)),
+					NS_SSCRISK_CEL_OR_SPROUT::min<difference_type>(rhs.from_begin(), sprout::size(sprout::lvalue_forward<Range>(lhs)))
+					),
+				sprout::next(
+					sprout::end(sprout::lvalue_forward<Range>(lhs)),
+					NS_SSCRISK_CEL_OR_SPROUT::max<difference_type>(
+						rhs.from_end(),
+						NS_SSCRISK_CEL_OR_SPROUT::min<difference_type>(rhs.from_begin() - sprout::size(sprout::lvalue_forward<Range>(lhs)), 0)
+						)
+					)
+				);
+		}
+		template<typename Range, typename Difference>
+		inline SPROUT_CONSTEXPR sprout::range::range_container<
+			typename sprout::container_traits<typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type>::iterator
+		>
+		operator|(Range&& lhs, sprout::adaptors::offset_holder<Difference> const& rhs) {
+			typedef typename sprout::container_traits<
+				typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type
+			>::difference_type difference_type;
+			return sprout::range::range_container<
+				typename sprout::container_traits<typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type>::iterator
+			>(
+				sprout::next(
+					sprout::begin(sprout::lvalue_forward<Range>(lhs)),
+					NS_SSCRISK_CEL_OR_SPROUT::min<difference_type>(rhs.from_begin(), sprout::size(sprout::lvalue_forward<Range>(lhs)))
+					),
+				sprout::end(sprout::lvalue_forward<Range>(lhs))
+				);
+		}
+	}	// namespace adaptors
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_RANGE_ADAPTOR_OFFSET_HPP
diff --git a/sprout/range/adaptor/piped.hpp b/sprout/range/adaptor/piped.hpp
new file mode 100644
index 00000000..2844bbff
--- /dev/null
+++ b/sprout/range/adaptor/piped.hpp
@@ -0,0 +1,129 @@
+#ifndef SPROUT_RANGE_ADAPTOR_PIPED_HPP
+#define SPROUT_RANGE_ADAPTOR_PIPED_HPP
+
+#include <type_traits>
+#include <sprout/config.hpp>
+#include <sprout/index_tuple.hpp>
+#include <sprout/utility/forward.hpp>
+#include <sprout/utility/lvalue_forward.hpp>
+#include <sprout/tuple/tuple.hpp>
+
+namespace sprout {
+	namespace adaptors {
+		namespace detail {
+			template<typename Range>
+			inline SPROUT_CONSTEXPR auto
+			apply_adaptors_impl(Range&& range)
+			-> decltype(sprout::forward<Range>(range))
+			{
+				return sprout::forward<Range>(range);
+			}
+			template<typename Range, typename Adaptor>
+			inline SPROUT_CONSTEXPR auto
+			apply_adaptors_impl(Range&& range, Adaptor const& adaptor)
+			-> decltype(sprout::forward<Range>(range) | adaptor)
+			{
+				return sprout::forward<Range>(range) | adaptor;
+			}
+			template<typename Range, typename Adaptor, typename... Tail>
+			inline SPROUT_CONSTEXPR auto
+			apply_adaptors_impl(Range&& range, Adaptor const& adaptor, Tail const&... tail)
+			-> decltype(sprout::adaptors::detail::apply_adaptors_impl(sprout::forward<Range>(range) | adaptor, tail...))
+			{
+				return sprout::adaptors::detail::apply_adaptors_impl(sprout::forward<Range>(range) | adaptor, tail...);
+			}
+		}	// namespace detail
+		//
+		// apply_adaptors
+		//
+		template<typename Range, typename... Adaptors>
+		SPROUT_CONSTEXPR auto
+		apply_adaptors(Range&& range, Adaptors const&... adaptors)
+		-> decltype(sprout::adaptors::detail::apply_adaptors_impl(sprout::forward<Range>(range), adaptors...))
+		{
+			return sprout::adaptors::detail::apply_adaptors_impl(sprout::forward<Range>(range), adaptors...);
+		}
+
+		namespace detail {
+			template<typename Range, typename AdaptorsTuple, sprout::index_t... Indexes>
+			SPROUT_CONSTEXPR auto
+			apply_adaptors_tuple_impl(Range&& range, AdaptorsTuple const& adaptors, sprout::index_tuple<Indexes...>)
+			-> decltype(sprout::adaptors::apply_adaptors(sprout::forward<Range>(range), sprout::tuples::get<Indexes>(adaptors)...))
+			{
+				return sprout::adaptors::apply_adaptors(sprout::forward<Range>(range), sprout::tuples::get<Indexes>(adaptors)...);
+			}
+			template<typename Range, typename AdaptorsTuple>
+			SPROUT_CONSTEXPR auto
+			apply_adaptors_tuple(Range&& range, AdaptorsTuple const& adaptors)
+			-> decltype(
+				sprout::adaptors::detail::apply_adaptors_tuple_impl(
+					sprout::forward<Range>(range), adaptors,
+					sprout::index_range<0, sprout::tuples::tuple_size<AdaptorsTuple>::value>::make()
+					)
+				)
+			{
+				return sprout::adaptors::detail::apply_adaptors_tuple_impl(
+					sprout::forward<Range>(range), adaptors,
+					sprout::index_range<0, sprout::tuples::tuple_size<AdaptorsTuple>::value>::make()
+					);
+			}
+		}	// namespace detail
+
+		//
+		// pipe_holder
+		//
+		template<typename... Adaptors>
+		class pipe_holder {
+		public:
+			typedef sprout::tuples::tuple<Adaptors...> adaptors_type;
+		private:
+			adaptors_type adaptors_;
+		public:
+			explicit SPROUT_CONSTEXPR pipe_holder(Adaptors const&... adaptors)
+				: adaptors_(adaptors...)
+			{}
+			SPROUT_CONSTEXPR adaptors_type const& adaptors() const {
+				return adaptors_;
+			}
+			template<typename Range>
+			SPROUT_CONSTEXPR auto
+			apply(Range&& range) const
+			-> decltype(sprout::adaptors::detail::apply_adaptors_tuple(sprout::forward<Range>(range), adaptors_))
+			{
+				return sprout::adaptors::detail::apply_adaptors_tuple(sprout::forward<Range>(range), adaptors_);
+			}
+		};
+
+		//
+		// piped_forwarder
+		//
+		class piped_forwarder {
+		public:
+			template<typename... Adaptors>
+			SPROUT_CONSTEXPR sprout::adaptors::pipe_holder<Adaptors...>
+			operator()(Adaptors const&... adaptors) {
+				return sprout::adaptors::pipe_holder<Adaptors...>(adaptors...);
+			}
+		};
+
+		//
+		// piped
+		//
+		namespace {
+			SPROUT_STATIC_CONSTEXPR sprout::adaptors::piped_forwarder piped{};
+		}	// anonymous-namespace
+
+		//
+		// operator|
+		//
+		template<typename Range, typename... Adaptors>
+		inline SPROUT_CONSTEXPR auto
+		operator|(Range&& lhs, sprout::adaptors::pipe_holder<Adaptors...> const& rhs)
+		-> decltype(rhs.apply(sprout::lvalue_forward<Range>(lhs)))
+		{
+			return rhs.apply(sprout::lvalue_forward<Range>(lhs));
+		}
+	}	// namespace adaptors
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_RANGE_ADAPTOR_PIPED_HPP
diff --git a/sprout/range/adaptor/sized.hpp b/sprout/range/adaptor/sized.hpp
index c19d6a5f..d8aa4c54 100644
--- a/sprout/range/adaptor/sized.hpp
+++ b/sprout/range/adaptor/sized.hpp
@@ -81,8 +81,7 @@ namespace sprout {
 			explicit SPROUT_CONSTEXPR sized_range(range_type& range)
 				: base_type(
 					sprout::begin(range),
-					sized_impl_type::static_size
-						< static_cast<typename sprout::container_traits<Range>::size_type>(sprout::size(range))
+					sized_impl_type::static_size < static_cast<typename sprout::container_traits<Range>::size_type>(sprout::size(range))
 						? sprout::next(sprout::begin(range), sized_impl_type::static_size)
 						: sprout::end(range)
 					)
diff --git a/sprout/range/adaptor/taken.hpp b/sprout/range/adaptor/taken.hpp
new file mode 100644
index 00000000..6fbf9c4e
--- /dev/null
+++ b/sprout/range/adaptor/taken.hpp
@@ -0,0 +1,77 @@
+#ifndef SPROUT_RANGE_ADAPTOR_TAKEN_HPP
+#define SPROUT_RANGE_ADAPTOR_TAKEN_HPP
+
+#include <type_traits>
+#include <sprout/config.hpp>
+#include <sprout/container/traits.hpp>
+#include <sprout/container/functions.hpp>
+#include <sprout/iterator/next.hpp>
+#include <sprout/range/range_container.hpp>
+#include <sprout/type_traits/lvalue_reference.hpp>
+#include <sprout/utility/lvalue_forward.hpp>
+#include HDR_ALGORITHM_SSCRISK_CEL_OR_SPROUT
+
+namespace sprout {
+	namespace adaptors {
+		//
+		// take_holder
+		//
+		template<typename Difference>
+		class take_holder {
+		public:
+			typedef Difference difference_type;
+		private:
+			difference_type distance_;
+		public:
+			explicit SPROUT_CONSTEXPR take_holder(difference_type distance)
+				: distance_(distance)
+			{}
+			SPROUT_CONSTEXPR difference_type const& distance() const {
+				return distance_;
+			}
+		};
+
+		//
+		// taken_forwarder
+		//
+		class taken_forwarder {
+		public:
+			template<typename Difference>
+			SPROUT_CONSTEXPR sprout::adaptors::take_holder<Difference>
+			operator()(Difference distance) {
+				return sprout::adaptors::take_holder<Difference>(distance);
+			}
+		};
+
+		//
+		// taken
+		//
+		namespace {
+			SPROUT_STATIC_CONSTEXPR sprout::adaptors::taken_forwarder taken{};
+		}	// anonymous-namespace
+
+		//
+		// operator|
+		//
+		template<typename Range, typename Difference>
+		inline SPROUT_CONSTEXPR sprout::range::range_container<
+			typename sprout::container_traits<typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type>::iterator
+		>
+		operator|(Range&& lhs, sprout::adaptors::take_holder<Difference> const& rhs) {
+			typedef typename sprout::container_traits<
+				typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type
+			>::difference_type difference_type;
+			return sprout::range::range_container<
+				typename sprout::container_traits<typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type>::iterator
+			>(
+				sprout::begin(sprout::lvalue_forward<Range>(lhs)),
+				sprout::next(
+					sprout::begin(sprout::lvalue_forward<Range>(lhs)),
+					NS_SSCRISK_CEL_OR_SPROUT::min<difference_type>(rhs.distance(), sprout::size(sprout::lvalue_forward<Range>(lhs)))
+					)
+				);
+		}
+	}	// namespace adaptors
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_RANGE_ADAPTOR_TAKEN_HPP
diff --git a/sprout/range/adaptor/taken_end.hpp b/sprout/range/adaptor/taken_end.hpp
new file mode 100644
index 00000000..ed25571a
--- /dev/null
+++ b/sprout/range/adaptor/taken_end.hpp
@@ -0,0 +1,77 @@
+#ifndef SPROUT_RANGE_ADAPTOR_TAKEN_END_HPP
+#define SPROUT_RANGE_ADAPTOR_TAKEN_END_HPP
+
+#include <type_traits>
+#include <sprout/config.hpp>
+#include <sprout/container/traits.hpp>
+#include <sprout/container/functions.hpp>
+#include <sprout/iterator/next.hpp>
+#include <sprout/range/range_container.hpp>
+#include <sprout/type_traits/lvalue_reference.hpp>
+#include <sprout/utility/lvalue_forward.hpp>
+#include HDR_ALGORITHM_SSCRISK_CEL_OR_SPROUT
+
+namespace sprout {
+	namespace adaptors {
+		//
+		// take_end_holder
+		//
+		template<typename Difference>
+		class take_end_holder {
+		public:
+			typedef Difference difference_type;
+		private:
+			difference_type distance_;
+		public:
+			explicit SPROUT_CONSTEXPR take_end_holder(difference_type distance)
+				: distance_(distance)
+			{}
+			SPROUT_CONSTEXPR difference_type const& distance() const {
+				return distance_;
+			}
+		};
+
+		//
+		// taken_end_forwarder
+		//
+		class taken_end_forwarder {
+		public:
+			template<typename Difference>
+			SPROUT_CONSTEXPR sprout::adaptors::take_end_holder<Difference>
+			operator()(Difference distance) {
+				return sprout::adaptors::take_end_holder<Difference>(distance);
+			}
+		};
+
+		//
+		// taken_end
+		//
+		namespace {
+			SPROUT_STATIC_CONSTEXPR sprout::adaptors::taken_end_forwarder taken_end{};
+		}	// anonymous-namespace
+
+		//
+		// operator|
+		//
+		template<typename Range, typename Difference>
+		inline SPROUT_CONSTEXPR sprout::range::range_container<
+			typename sprout::container_traits<typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type>::iterator
+		>
+		operator|(Range&& lhs, sprout::adaptors::take_end_holder<Difference> const& rhs) {
+			typedef typename sprout::container_traits<
+				typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type
+			>::difference_type difference_type;
+			return sprout::range::range_container<
+				typename sprout::container_traits<typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type>::iterator
+			>(
+				sprout::next(
+					sprout::end(sprout::lvalue_forward<Range>(lhs)),
+					NS_SSCRISK_CEL_OR_SPROUT::max<difference_type>(rhs.distance(), -sprout::size(sprout::lvalue_forward<Range>(lhs)))
+					),
+				sprout::end(sprout::lvalue_forward<Range>(lhs))
+				);
+		}
+	}	// namespace adaptors
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_RANGE_ADAPTOR_TAKEN_END_HPP
diff --git a/sprout/range/adaptor/window.hpp b/sprout/range/adaptor/window.hpp
new file mode 100644
index 00000000..5ffda72c
--- /dev/null
+++ b/sprout/range/adaptor/window.hpp
@@ -0,0 +1,122 @@
+#ifndef SPROUT_RANGE_ADAPTOR_WINDOW_HPP
+#define SPROUT_RANGE_ADAPTOR_WINDOW_HPP
+
+#include <type_traits>
+#include <sprout/config.hpp>
+#include <sprout/container/traits.hpp>
+#include <sprout/container/functions.hpp>
+#include <sprout/iterator/next.hpp>
+#include <sprout/range/range_container.hpp>
+#include <sprout/type_traits/lvalue_reference.hpp>
+#include <sprout/type_traits/arithmetic_promote.hpp>
+#include <sprout/utility/lvalue_forward.hpp>
+#include HDR_ALGORITHM_SSCRISK_CEL_OR_SPROUT
+
+namespace sprout {
+	namespace adaptors {
+		//
+		// window_holder
+		//
+		template<typename Difference1, typename Difference2 = void>
+		class window_holder {
+		public:
+			typedef typename sprout::arithmetic_promote<Difference1, Difference2>::type difference_type;
+		private:
+			difference_type to_first_;
+			difference_type to_last_;
+		public:
+			SPROUT_CONSTEXPR window_holder(difference_type to_first, difference_type to_last)
+				: to_first_(to_first), to_last_(to_last)
+			{}
+			SPROUT_CONSTEXPR difference_type const& to_first() const {
+				return to_first_;
+			}
+			SPROUT_CONSTEXPR difference_type const& to_last() const {
+				return to_last_;
+			}
+		};
+		template<typename Difference>
+		class window_holder<Difference, void> {
+		public:
+			typedef Difference difference_type;
+		private:
+			difference_type to_first_;
+		public:
+			explicit SPROUT_CONSTEXPR window_holder(difference_type to_first)
+				: to_first_(to_first)
+			{}
+			SPROUT_CONSTEXPR difference_type const& to_first() const {
+				return to_first_;
+			}
+		};
+
+		//
+		// window_forwarder
+		//
+		class window_forwarder {
+		public:
+			template<typename Difference1, typename Difference2>
+			SPROUT_CONSTEXPR sprout::adaptors::window_holder<Difference1, Difference2>
+			operator()(Difference1 to_first, Difference2 to_last) {
+				return sprout::adaptors::window_holder<Difference1, Difference2>(to_first, to_last);
+			}
+			template<typename Difference>
+			SPROUT_CONSTEXPR sprout::adaptors::window_holder<Difference>
+			operator()(Difference to_first) {
+				return sprout::adaptors::window_holder<Difference>(to_first);
+			}
+		};
+
+		//
+		// window
+		//
+		namespace {
+			SPROUT_STATIC_CONSTEXPR sprout::adaptors::window_forwarder window{};
+		}	// anonymous-namespace
+
+		//
+		// operator|
+		//
+		template<typename Range, typename Difference1, typename Difference2>
+		inline SPROUT_CONSTEXPR sprout::range::range_container<
+			typename sprout::container_traits<typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type>::iterator
+		>
+		operator|(Range&& lhs, sprout::adaptors::window_holder<Difference1, Difference2> const& rhs) {
+			typedef typename sprout::container_traits<
+				typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type
+			>::difference_type difference_type;
+			return sprout::range::range_container<
+				typename sprout::container_traits<typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type>::iterator
+			>(
+				sprout::next(
+					sprout::begin(sprout::lvalue_forward<Range>(lhs)),
+					NS_SSCRISK_CEL_OR_SPROUT::min<difference_type>(rhs.to_first(), sprout::size(sprout::lvalue_forward<Range>(lhs)))
+					),
+				sprout::next(
+					sprout::begin(sprout::lvalue_forward<Range>(lhs)),
+					NS_SSCRISK_CEL_OR_SPROUT::min<difference_type>(rhs.to_last(), sprout::size(sprout::lvalue_forward<Range>(lhs)))
+					)
+				);
+		}
+		template<typename Range, typename Difference>
+		inline SPROUT_CONSTEXPR sprout::range::range_container<
+			typename sprout::container_traits<typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type>::iterator
+		>
+		operator|(Range&& lhs, sprout::adaptors::window_holder<Difference> const& rhs) {
+			typedef typename sprout::container_traits<
+				typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type
+			>::difference_type difference_type;
+			return sprout::range::range_container<
+				typename sprout::container_traits<typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type>::iterator
+			>(
+				sprout::next(
+					sprout::begin(sprout::lvalue_forward<Range>(lhs)),
+					NS_SSCRISK_CEL_OR_SPROUT::min<difference_type>(rhs.to_first(), sprout::size(sprout::lvalue_forward<Range>(lhs)))
+					),
+				sprout::end(sprout::lvalue_forward<Range>(lhs))
+				);
+		}
+	}	// namespace adaptors
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_RANGE_ADAPTOR_WINDOW_HPP