Added Range iterator

src/lib.rs

@@ -176,6 +176,7 @@ mod combinations;
 mod combinations_with_replacement;
 mod exactly_one_err;
 mod diff;
+mod range;
 mod format;
 #[cfg(feature = "use_std")]
 mod group_map;
@@ -396,6 +397,42 @@ pub trait Itertools : Iterator {
         intersperse::intersperse(self, element)
     }
 
+    /// Limits an iterator to a given range.
+    /// Similar to [`Iterator::skip`] and [`Iterator::take`],
+    /// but some may consider it to be more readable.
+    ///
+	/// # Examples
+	///
+    /// ```
+    /// use itertools::Itertools;
+    ///
+    /// let vec = vec![3, 1, 4, 1, 5];
+    ///
+    /// let mut range: Vec<_> = 
+    ///        vec.iter().range(1..=3).copied().collect();
+    /// assert_eq!(&range, &[1, 4, 1]);
+    ///
+    /// // It works with other types of ranges, too
+    /// range = vec.iter().range(..2).copied().collect();
+    /// assert_eq!(&range, &[3, 1]);
+	///
+    /// range = vec.iter().range(0..1).copied().collect();
+    /// assert_eq!(&range, &[3]);
+    ///
+    /// range = vec.iter().range(2..).copied().collect();
+    /// assert_eq!(&range, &[4, 1, 5]);
+    ///
+    /// range = vec.iter().range(..).copied().collect();
+    /// assert_eq!(range, vec);
+    /// ```
+	fn range<R>(self, range: R)
+		-> R::IterTo
+		where R: range::IntoRangeIter<Self>,
+			  Self: Sized
+    {
+        range::range(self, range)
+    }
+
     /// Create an iterator which iterates over both this and the specified
     /// iterator simultaneously, yielding pairs of two optional elements.
     ///

src/range.rs

@@ -0,0 +1,86 @@
+use core::ops::{ Range, RangeTo, RangeFrom, RangeFull, RangeInclusive, RangeToInclusive };
+use core::iter::{Skip, Take};
+use crate::Itertools;
+
+/// Used by the ``range`` function to know which iterator
+/// to turn different ranges into.
+pub trait IntoRangeIter<IterFrom> {
+	type IterTo;
+
+	fn into_range_iter(self, from: IterFrom) -> Self::IterTo;
+}
+
+impl<I> IntoRangeIter<I> for Range<usize>
+	where I: Iterator
+{
+	type IterTo = Take<Skip<I>>;
+
+	fn into_range_iter(self, iter: I) -> Self::IterTo {
+		iter.skip(self.start)
+			.take(self.end.saturating_sub(self.start))
+	}
+}
+
+impl<I> IntoRangeIter<I> for RangeInclusive<usize>
+	where I: Iterator
+{
+	type IterTo = Take<Skip<I>>;
+
+	fn into_range_iter(self, iter: I) -> Self::IterTo {
+		iter.skip(*self.start())
+			.take(
+				(1 + *self.end())
+				.saturating_sub(*self.start())
+			)
+	}
+}
+
+impl<I> IntoRangeIter<I> for RangeTo<usize>
+	where I: Iterator
+{
+	type IterTo = Take<I>;
+
+	fn into_range_iter(self, iter: I) -> Self::IterTo {
+		iter.take(self.end)
+	}
+}
+
+impl<I> IntoRangeIter<I> for RangeToInclusive<usize>
+	where I: Iterator
+{
+	type IterTo = Take<I>;
+
+	fn into_range_iter(self, iter: I) -> Self::IterTo {
+		iter.take(self.end + 1)
+	}
+}
+
+impl<I> IntoRangeIter<I> for RangeFrom<usize>
+	where I: Iterator
+{
+	type IterTo = Skip<I>;
+
+	fn into_range_iter(self, iter: I) -> Self::IterTo {
+		iter.skip(self.start)
+	}
+}
+
+impl<I> IntoRangeIter<I> for RangeFull
+	where I: Iterator
+{
+	type IterTo = I;
+
+	fn into_range_iter(self, iter: I) -> Self::IterTo {
+		iter
+	}
+}
+
+/// Limits an iterator to a range. See [`Itertools::range`]
+/// for more information.
+pub fn range<I, R>(iter: I, range: R)
+    -> R::IterTo
+    where I: IntoIterator,
+          R: IntoRangeIter<I::IntoIter>
+{
+	range.into_range_iter(iter.into_iter())
+}