Merge pull request #25 from WanderLanz/attrs

derive Debug, add must_use and inline attributes

src/adapters/chain.rs

@@ -8,7 +8,8 @@ use crate::LendingIterator;
 ///
 /// [`LendingIterator`]: crate::LendingIterator
 /// [`chain`]: crate::LendingIterator::chain
-#[derive(Clone)]
+#[derive(Clone, Debug)]
+#[must_use = "iterators are lazy and do nothing unless consumed"]
 pub struct Chain<A, B> {
     a: A,
     b: B,
@@ -34,6 +35,7 @@ where
             Self: 'a
     ;
 
+    #[inline]
     fn next(&mut self) -> Option<A::Item<'_>> {
         if self.a_done {
             self.b.next()

src/adapters/cloned.rs

@@ -9,7 +9,8 @@ use crate::LendingIterator;
 ///
 /// [`LendingIterator`]: crate::LendingIterator
 /// [`cloned`]: crate::LendingIterator::cloned
-#[derive(Clone)]
+#[derive(Clone, Debug)]
+#[must_use = "iterators are lazy and do nothing unless consumed"]
 pub struct Cloned<I> {
     iter: I,
 }

src/adapters/enumerate.rs

@@ -1,7 +1,8 @@
 use crate::LendingIterator;
 
 /// A lending iterator that yields the current count and the element during iteration.
-#[derive(Clone)]
+#[derive(Clone, Debug)]
+#[must_use = "iterators are lazy and do nothing unless consumed"]
 pub struct Enumerate<I> {
     count: usize,
     iter: I,
@@ -15,6 +16,8 @@ impl<I> Enumerate<I> {
 
 impl<I: LendingIterator> LendingIterator for Enumerate<I> {
     type Item<'a> = (usize, I::Item<'a>) where Self: 'a;
+
+    #[inline]
     fn next(&mut self) -> Option<Self::Item<'_>> {
         let item = self.iter.next()?;
         let count = self.count;

src/adapters/filter.rs

@@ -1,4 +1,5 @@
 use crate::LendingIterator;
+use core::fmt;
 
 /// A lending iterator that filters the elements of `iter` with `predicate`.
 ///
@@ -8,6 +9,7 @@ use crate::LendingIterator;
 /// [`LendingIterator`]: crate::LendingIterator
 /// [`filter`]: crate::LendingIterator::filter
 #[derive(Clone)]
+#[must_use = "iterators are lazy and do nothing unless consumed"]
 pub struct Filter<I, P> {
     iter: I,
     predicate: P,
@@ -19,6 +21,12 @@ impl<I, P> Filter<I, P> {
     }
 }
 
+impl<I: fmt::Debug, P> fmt::Debug for Filter<I, P> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Filter").field("iter", &self.iter).finish()
+    }
+}
+
 impl<I, P> LendingIterator for Filter<I, P>
 where
     I: LendingIterator,
@@ -28,6 +36,7 @@ where
     where
         Self: 'a;
 
+    #[inline]
     fn next(&mut self) -> Option<Self::Item<'_>> {
         loop {
             // SAFETY: see https://docs.rs/polonius-the-crab/0.3.1/polonius_the_crab/#the-arcanemagic

src/adapters/filter_map.rs

@@ -1,4 +1,5 @@
 use crate::{LendingIterator, OptionTrait, SingleArgFnMut, SingleArgFnOnce};
+use core::fmt;
 
 /// A lending iterator that uses `f` to both filter and map elements from `iter`.
 ///
@@ -8,6 +9,7 @@ use crate::{LendingIterator, OptionTrait, SingleArgFnMut, SingleArgFnOnce};
 /// [`LendingIterator`]: crate::LendingIterator
 /// [`filter_map`]: crate::LendingIterator::filter_map
 #[derive(Clone)]
+#[must_use = "iterators are lazy and do nothing unless consumed"]
 pub struct FilterMap<I, F> {
     iter: I,
     f: F,
@@ -19,6 +21,14 @@ impl<I, F> FilterMap<I, F> {
     }
 }
 
+impl<I: fmt::Debug, F> fmt::Debug for FilterMap<I, F> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("FilterMap")
+            .field("iter", &self.iter)
+            .finish()
+    }
+}
+
 impl<I, F> LendingIterator for FilterMap<I, F>
 where
     I: LendingIterator,
@@ -29,6 +39,7 @@ where
     where
         Self: 'a;
 
+    #[inline]
     fn next(&mut self) -> Option<Self::Item<'_>> {
         loop {
             // SAFETY: see https://docs.rs/polonius-the-crab/0.3.1/polonius_the_crab/#the-arcanemagic

src/adapters/map.rs

@@ -1,4 +1,5 @@
 use crate::{LendingIterator, SingleArgFnMut, SingleArgFnOnce};
+use core::fmt;
 
 /// A lending iterator that maps the elements of `iter` with `f`.
 ///
@@ -8,6 +9,7 @@ use crate::{LendingIterator, SingleArgFnMut, SingleArgFnOnce};
 /// [`LendingIterator`]: crate::LendingIterator
 /// [`map`]: crate::LendingIterator::map
 #[derive(Clone)]
+#[must_use = "iterators are lazy and do nothing unless consumed"]
 pub struct Map<I, F> {
     iter: I,
     f: F,
@@ -19,6 +21,12 @@ impl<I, F> Map<I, F> {
     }
 }
 
+impl<I: fmt::Debug, F> fmt::Debug for Map<I, F> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Map").field("iter", &self.iter).finish()
+    }
+}
+
 impl<I, F> LendingIterator for Map<I, F>
 where
     I: LendingIterator,
@@ -28,6 +36,7 @@ where
         where
             Self: 'a;
 
+    #[inline]
     fn next(&mut self) -> Option<Self::Item<'_>> {
         self.iter.next().map(&mut self.f)
     }

src/adapters/skip.rs

@@ -1,7 +1,8 @@
 use crate::LendingIterator;
 
 /// A lending iterator that skips over the first `n` items of `iter`.
-#[derive(Clone)]
+#[derive(Clone, Debug)]
+#[must_use = "iterators are lazy and do nothing unless consumed"]
 pub struct Skip<I> {
     iter: I,
     n: usize,
@@ -19,6 +20,7 @@ where
 {
     type Item<'a> = I::Item<'a> where I: 'a;
 
+    #[inline]
     fn next(&mut self) -> Option<I::Item<'_>> {
         if self.n > 0 {
             self.iter.nth(core::mem::take(&mut self.n))
@@ -27,6 +29,7 @@ where
         }
     }
 
+    #[inline]
     fn size_hint(&self) -> (usize, Option<usize>) {
         let (lower, upper) = self.iter.size_hint();
 

src/adapters/step_by.rs

@@ -7,14 +7,16 @@ use crate::LendingIterator;
 ///
 /// [`LendingIterator`]: crate::LendingIterator
 /// [`step_by`]: crate::LendingIterator::step_by
-#[derive(Clone)]
+#[derive(Clone, Debug)]
+#[must_use = "iterators are lazy and do nothing unless consumed"]
 pub struct StepBy<I> {
     iter: I,
     step: usize,
     first_take: bool,
 }
 
 impl<I> StepBy<I> {
+    #[inline]
     pub(crate) fn new(iter: I, step: usize) -> StepBy<I> {
         assert!(step != 0);
         StepBy {
@@ -34,6 +36,7 @@ where
             Self: 'a
     ;
 
+    #[inline]
     fn next(&mut self) -> Option<Self::Item<'_>> {
         if self.first_take {
             self.first_take = false;

src/adapters/take.rs

@@ -1,7 +1,8 @@
 use crate::LendingIterator;
 
 /// A Lending iterator that only lends the first `n` iterations of `iter`.
-#[derive(Clone)]
+#[derive(Clone, Debug)]
+#[must_use = "iterators are lazy and do nothing unless consumed"]
 pub struct Take<I> {
     iter: I,
     n: usize,
@@ -22,6 +23,7 @@ where
 {
     type Item<'a> = I::Item<'a> where I: 'a;
 
+    #[inline]
     #[allow(clippy::if_not_else)]
     fn next(&mut self) -> Option<Self::Item<'_>> {
         if self.n != 0 {

src/adapters/take_while.rs

@@ -1,9 +1,11 @@
 use crate::LendingIterator;
+use core::fmt;
 
 /// A lending iterator that yields items based on a predicate.
 ///
 /// This iterator is fused.
 #[derive(Clone)]
+#[must_use = "iterators are lazy and do nothing unless consumed"]
 pub struct TakeWhile<I, P> {
     iter: I,
     predicate: P,
@@ -20,13 +22,23 @@ impl<I, P> TakeWhile<I, P> {
     }
 }
 
+impl<I: fmt::Debug, P> fmt::Debug for TakeWhile<I, P> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("TakeWhile")
+            .field("iter", &self.iter)
+            .field("done", &self.done)
+            .finish()
+    }
+}
+
 impl<I, P> LendingIterator for TakeWhile<I, P>
 where
     I: LendingIterator,
-    P: for<'a> FnMut(&I::Item<'a>) -> bool
+    P: for<'a> FnMut(&I::Item<'a>) -> bool,
 {
     type Item<'a> = I::Item<'a> where I: 'a, P: 'a;
 
+    #[inline]
     fn next(&mut self) -> Option<Self::Item<'_>> {
         if self.done {
             None
@@ -41,6 +53,7 @@ where
         }
     }
 
+    #[inline]
     fn size_hint(&self) -> (usize, Option<usize>) {
         if self.done {
             (0, Some(0))

src/adapters/zip.rs

@@ -7,7 +7,8 @@ use crate::LendingIterator;
 ///
 /// [`LendingIterator`]: crate::LendingIterator
 /// [`zip`]: crate::LendingIterator::zip
-#[derive(Clone)]
+#[derive(Clone, Debug)]
+#[must_use = "iterators are lazy and do nothing unless consumed"]
 pub struct Zip<A, B> {
     a: A,
     b: B,
@@ -28,6 +29,7 @@ where
             A: 'a, B: 'a
     ;
 
+    #[inline]
     fn next(&mut self) -> Option<Self::Item<'_>> {
         let a = self.a.next()?;
         let b = self.b.next()?;