Merge pull request #23 from ratmice/skip

add skip

src/adapters/mod.rs

@@ -4,6 +4,7 @@ mod enumerate;
 mod filter;
 mod filter_map;
 mod map;
+mod skip;
 mod step_by;
 mod take;
 mod take_while;
@@ -14,6 +15,7 @@ pub use self::enumerate::Enumerate;
 pub use self::filter::Filter;
 pub use self::filter_map::FilterMap;
 pub use self::map::{IntoIter, Map};
+pub use self::skip::Skip;
 pub use self::step_by::StepBy;
 pub use self::take::Take;
 pub use self::take_while::TakeWhile;

src/adapters/skip.rs

@@ -0,0 +1,47 @@
+use crate::LendingIterator;
+
+/// A lending iterator that skips over the first `n` items of `iter`.
+#[derive(Clone)]
+pub struct Skip<I> {
+    n: usize,
+    iter: I,
+}
+
+impl<I> Skip<I> {
+    pub(crate) fn new(iter: I, n: usize) -> Skip<I> {
+        Skip { iter, n }
+    }
+}
+
+impl<I> LendingIterator for Skip<I>
+where
+    I: LendingIterator,
+{
+    type Item<'a> = I::Item<'a> where I: 'a;
+
+    fn next(&mut self) -> Option<I::Item<'_>> {
+        if self.n > 0 {
+            self.iter.nth(core::mem::take(&mut self.n))
+        } else {
+            self.iter.next()
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let (lower, upper) = self.iter.size_hint();
+
+        let lower = lower.saturating_sub(self.n);
+        let upper = upper.map(|x| x.saturating_sub(self.n));
+        (lower, upper)
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::ToLendingIterator;
+    #[test]
+    fn test() {
+        assert_eq!((0..5).into_lending().skip(1).nth(1), (0..5).skip(1).nth(1))
+    }
+}

src/traits/lending_iterator.rs

@@ -2,7 +2,7 @@ use std::{num::NonZeroUsize, ops::Deref};
 
 use crate::{
     Chain, Cloned, Enumerate, Filter, FilterMap, Map, OptionTrait, SingleArgFnMut, SingleArgFnOnce,
-    StepBy, Take, Zip, TakeWhile,
+    Skip, StepBy, Take, Zip, TakeWhile,
 };
 
 /// Like [`Iterator`], but items may borrow from `&mut self`.
@@ -213,4 +213,12 @@ pub trait LendingIterator {
     {
         Enumerate::new(self)
     }
+
+    /// Creates a lending iterator that skips over the first `n` elements of self.
+    fn skip(self, n: usize) -> Skip<Self>
+    where
+        Self: Sized,
+    {
+        Skip::new(self, n)
+    }
 }