Optimize Iterator::last() for PyList & PyTuple and `Iterator::c…

…ount()` for `PyDict`, `PyList`, `PyTuple` & `PySet` (#4878)

* Optimize `Iterator::last()` for `PyList` & `PyTuple`

* Optimize `Iterator::count()` for `PyDict`, `PyList`, `PyTuple` & `PySet`

newsfragments/4878.added.md

@@ -0,0 +1,2 @@
+- Optimizes `last` for `BoundListIterator`, `BoundTupleIterator` and `BorrowedTupleIterator`
+- Optimizes `Iterator::count()` for `PyDict`, `PyList`, `PyTuple` & `PySet`

src/types/dict.rs

@@ -534,6 +534,14 @@ impl<'py> Iterator for BoundDictIterator<'py> {
         (len, Some(len))
     }
 
+    #[inline]
+    fn count(self) -> usize
+    where
+        Self: Sized,
+    {
+        self.len()
+    }
+
     #[inline]
     #[cfg(Py_GIL_DISABLED)]
     fn fold<B, F>(mut self, init: B, mut f: F) -> B
@@ -736,6 +744,14 @@ mod borrowed_iter {
             let len = self.len();
             (len, Some(len))
         }
+
+        #[inline]
+        fn count(self) -> usize
+        where
+            Self: Sized,
+        {
+            self.len()
+        }
     }
 
     impl ExactSizeIterator for BorrowedDictIter<'_, '_> {
@@ -1657,4 +1673,12 @@ mod tests {
                 .is_err());
         });
     }
+
+    #[test]
+    fn test_iter_count() {
+        Python::with_gil(|py| {
+            let dict = [(1, 1), (2, 2), (3, 3)].into_py_dict(py).unwrap();
+            assert_eq!(dict.iter().count(), 3);
+        })
+    }
 }

src/types/frozenset.rs

@@ -237,6 +237,14 @@ impl<'py> Iterator for BoundFrozenSetIterator<'py> {
     fn size_hint(&self) -> (usize, Option<usize>) {
         (self.remaining, Some(self.remaining))
     }
+
+    #[inline]
+    fn count(self) -> usize
+    where
+        Self: Sized,
+    {
+        self.len()
+    }
 }
 
 impl ExactSizeIterator for BoundFrozenSetIterator<'_> {
@@ -358,4 +366,12 @@ mod tests {
             assert!(!set.contains(3).unwrap());
         });
     }
+
+    #[test]
+    fn test_iter_count() {
+        Python::with_gil(|py| {
+            let set = PyFrozenSet::new(py, vec![1, 2, 3]).unwrap();
+            assert_eq!(set.iter().count(), 3);
+        })
+    }
 }

src/types/list.rs

@@ -695,6 +695,22 @@ impl<'py> Iterator for BoundListIterator<'py> {
         (len, Some(len))
     }
 
+    #[inline]
+    fn count(self) -> usize
+    where
+        Self: Sized,
+    {
+        self.len()
+    }
+
+    #[inline]
+    fn last(mut self) -> Option<Self::Item>
+    where
+        Self: Sized,
+    {
+        self.next_back()
+    }
+
     #[inline]
     #[cfg(all(Py_GIL_DISABLED, not(feature = "nightly")))]
     fn fold<B, F>(mut self, init: B, mut f: F) -> B
@@ -1778,4 +1794,21 @@ mod tests {
             assert_eq!(iter4.next_back().unwrap().extract::<i32>().unwrap(), 5);
         })
     }
+
+    #[test]
+    fn test_iter_last() {
+        Python::with_gil(|py| {
+            let list = PyList::new(py, vec![1, 2, 3]).unwrap();
+            let last = list.iter().last();
+            assert_eq!(last.unwrap().extract::<i32>().unwrap(), 3);
+        })
+    }
+
+    #[test]
+    fn test_iter_count() {
+        Python::with_gil(|py| {
+            let list = PyList::new(py, vec![1, 2, 3]).unwrap();
+            assert_eq!(list.iter().count(), 3);
+        })
+    }
 }

src/types/set.rs

@@ -267,6 +267,14 @@ impl<'py> Iterator for BoundSetIterator<'py> {
     fn size_hint(&self) -> (usize, Option<usize>) {
         (self.remaining, Some(self.remaining))
     }
+
+    #[inline]
+    fn count(self) -> usize
+    where
+        Self: Sized,
+    {
+        self.len()
+    }
 }
 
 impl ExactSizeIterator for BoundSetIterator<'_> {
@@ -479,4 +487,12 @@ mod tests {
             assert_eq!(iter.size_hint(), (0, Some(0)));
         });
     }
+
+    #[test]
+    fn test_iter_count() {
+        Python::with_gil(|py| {
+            let set = PySet::new(py, vec![1, 2, 3]).unwrap();
+            assert_eq!(set.iter().count(), 3);
+        })
+    }
 }

src/types/tuple.rs

@@ -377,6 +377,22 @@ impl<'py> Iterator for BoundTupleIterator<'py> {
         (len, Some(len))
     }
 
+    #[inline]
+    fn count(self) -> usize
+    where
+        Self: Sized,
+    {
+        self.len()
+    }
+
+    #[inline]
+    fn last(mut self) -> Option<Self::Item>
+    where
+        Self: Sized,
+    {
+        self.next_back()
+    }
+
     #[inline]
     #[cfg(not(feature = "nightly"))]
     fn nth(&mut self, n: usize) -> Option<Self::Item> {
@@ -548,6 +564,22 @@ impl<'a, 'py> Iterator for BorrowedTupleIterator<'a, 'py> {
         let len = self.len();
         (len, Some(len))
     }
+
+    #[inline]
+    fn count(self) -> usize
+    where
+        Self: Sized,
+    {
+        self.len()
+    }
+
+    #[inline]
+    fn last(mut self) -> Option<Self::Item>
+    where
+        Self: Sized,
+    {
+        self.next_back()
+    }
 }
 
 impl DoubleEndedIterator for BorrowedTupleIterator<'_, '_> {
@@ -1728,4 +1760,21 @@ mod tests {
             assert_eq!(iter4.next_back().unwrap().extract::<i32>().unwrap(), 5);
         })
     }
+
+    #[test]
+    fn test_iter_last() {
+        Python::with_gil(|py| {
+            let tuple = PyTuple::new(py, vec![1, 2, 3]).unwrap();
+            let last = tuple.iter().last();
+            assert_eq!(last.unwrap().extract::<i32>().unwrap(), 3);
+        })
+    }
+
+    #[test]
+    fn test_iter_count() {
+        Python::with_gil(|py| {
+            let tuple = PyTuple::new(py, vec![1, 2, 3]).unwrap();
+            assert_eq!(tuple.iter().count(), 3);
+        })
+    }
 }