Merge pull request #628 from therealbnut/more_into_iter_traits

sgued · web-flow · commit 38c004efccb0 · 2025-11-04T12:43:12.000Z
Add ExactSizeIterator, FusedIterator, and DoubleEndedIterator on IntoIter types
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -19,6 +19,9 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 - Added `retain_mut` to `Deque`
 - Added `into_raw` to `Box`
 - Added `from_raw` to `Box`
+- Added `FusedIterator` to `vec::IntoIter`, `deque::IntoIter`, `index_map::IntoIter` and `linear_map::IntoIter`.
+- Added `ExactSizeIterator` to `vec::IntoIter`, `deque::IntoIter`, `index_map::IntoIter` and `linear_map::IntoIter`.
+- Added `DoubleEndedIterator` to `vec::IntoIter` and `deque::IntoIter`.
 
 ## [v0.9.1] - 2025-08-19
 
diff --git a/src/deque.rs b/src/deque.rs
@@ -1095,6 +1095,21 @@ impl<T, const N: usize> Iterator for IntoIter<T, N> {
     fn next(&mut self) -> Option<Self::Item> {
         self.deque.pop_front()
     }
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let len = self.len();
+        (len, Some(len))
+    }
+}
+impl<T, const N: usize> DoubleEndedIterator for IntoIter<T, N> {
+    fn next_back(&mut self) -> Option<Self::Item> {
+        self.deque.pop_back()
+    }
+}
+impl<T, const N: usize> FusedIterator for IntoIter<T, N> {}
+impl<T, const N: usize> ExactSizeIterator for IntoIter<T, N> {
+    fn len(&self) -> usize {
+        self.deque.len()
+    }
 }
 
 impl<T, const N: usize> IntoIterator for Deque<T, N> {
@@ -1421,6 +1436,41 @@ mod tests {
         assert_eq!(items.next(), None);
     }
 
+    #[test]
+    fn iter_move_back() {
+        let mut v: Deque<i32, 4> = Deque::new();
+
+        v.push_back(0).unwrap();
+        v.push_back(1).unwrap();
+        v.push_back(2).unwrap();
+        v.push_back(3).unwrap();
+
+        let mut items = v.into_iter();
+        assert_eq!(items.next_back(), Some(3));
+        assert_eq!(items.next_back(), Some(2));
+        assert_eq!(items.next_back(), Some(1));
+        assert_eq!(items.next_back(), Some(0));
+        assert_eq!(items.next_back(), None);
+    }
+
+    #[test]
+    fn iter_move_len() {
+        let mut v: Deque<i32, 3> = Deque::new();
+
+        v.push_back(0).unwrap();
+        v.push_back(1).unwrap();
+        v.push_back(2).unwrap();
+
+        let mut items = v.into_iter();
+        assert_eq!(items.len(), 3);
+        let _ = items.next();
+        assert_eq!(items.len(), 2);
+        let _ = items.next_back();
+        assert_eq!(items.len(), 1);
+        let _ = items.next();
+        assert_eq!(items.len(), 0);
+    }
+
     #[test]
     fn iter_move_drop() {
         droppable!();
diff --git a/src/index_map.rs b/src/index_map.rs
@@ -3,6 +3,7 @@ use core::{
     borrow::Borrow,
     fmt,
     hash::{BuildHasher, Hash},
+    iter::FusedIterator,
     mem,
     num::NonZeroU32,
     ops, slice,
@@ -1471,6 +1472,19 @@ impl<K, V, const N: usize> Iterator for IntoIter<K, V, N> {
     fn next(&mut self) -> Option<Self::Item> {
         self.entries.pop().map(|bucket| (bucket.key, bucket.value))
     }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let len = self.len();
+        (len, Some(len))
+    }
+}
+
+impl<K, V, const N: usize> FusedIterator for IntoIter<K, V, N> {}
+
+impl<K, V, const N: usize> ExactSizeIterator for IntoIter<K, V, N> {
+    fn len(&self) -> usize {
+        self.entries.len()
+    }
 }
 
 impl<K, V, S, const N: usize> IntoIterator for IndexMap<K, V, S, N> {
@@ -1744,8 +1758,23 @@ mod tests {
         src.insert("k4", "v4").unwrap();
         let clone = src.clone();
         for (k, v) in clone.into_iter() {
-            assert_eq!(v, *src.get(k).unwrap());
+            assert_eq!(v, src.remove(k).unwrap());
         }
+        assert!(src.is_empty());
+    }
+
+    #[test]
+    fn into_iter_len() {
+        let mut src: FnvIndexMap<_, _, 2> = FnvIndexMap::new();
+        src.insert("k1", "v1").unwrap();
+        src.insert("k2", "v2").unwrap();
+
+        let mut items = src.into_iter();
+        assert_eq!(items.len(), 2);
+        let _ = items.next();
+        assert_eq!(items.len(), 1);
+        let _ = items.next();
+        assert_eq!(items.len(), 0);
     }
 
     #[test]
diff --git a/src/linear_map.rs b/src/linear_map.rs
@@ -2,7 +2,7 @@
 //!
 //! Note that as this map doesn't use hashing so most operations are *O*(n) instead of *O*(1).
 
-use core::{borrow::Borrow, fmt, mem, ops, slice};
+use core::{borrow::Borrow, fmt, iter::FusedIterator, mem, ops, slice};
 
 #[cfg(feature = "zeroize")]
 use zeroize::Zeroize;
@@ -606,6 +606,22 @@ where
     fn next(&mut self) -> Option<Self::Item> {
         self.inner.next()
     }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let len = self.len();
+        (len, Some(len))
+    }
+}
+
+impl<K, V, const N: usize> FusedIterator for IntoIter<K, V, N> where K: Eq {}
+
+impl<K, V, const N: usize> ExactSizeIterator for IntoIter<K, V, N>
+where
+    K: Eq,
+{
+    fn len(&self) -> usize {
+        self.inner.len()
+    }
 }
 
 impl<K, V, const N: usize> IntoIterator for LinearMap<K, V, N>
@@ -877,6 +893,20 @@ mod test {
         for (k, v) in clone.into_iter() {
             assert_eq!(v, src.remove(k).unwrap());
         }
+        assert!(src.is_empty());
+    }
+
+    #[test]
+    fn into_iter_len() {
+        let mut src: LinearMap<_, _, 2> = LinearMap::new();
+        src.insert("k1", "v1").unwrap();
+        src.insert("k2", "v2").unwrap();
+        let mut items = src.into_iter();
+        assert_eq!(items.len(), 2);
+        let _ = items.next();
+        assert_eq!(items.len(), 1);
+        let _ = items.next();
+        assert_eq!(items.len(), 0);
     }
 
     fn _test_variance_value<'a: 'b, 'b>(
diff --git a/src/vec/mod.rs b/src/vec/mod.rs
@@ -1,6 +1,7 @@
 //! A fixed capacity [`Vec`](https://doc.rust-lang.org/std/vec/struct.Vec.html).
 
 use core::borrow;
+use core::iter::FusedIterator;
 use core::marker::PhantomData;
 use core::{
     cmp::Ordering,
@@ -1472,6 +1473,31 @@ impl<T, LenT: LenType, const N: usize> Iterator for IntoIter<T, N, LenT> {
             None
         }
     }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let len = self.len();
+        (len, Some(len))
+    }
+}
+
+impl<T, LenT: LenType, const N: usize> DoubleEndedIterator for IntoIter<T, N, LenT> {
+    fn next_back(&mut self) -> Option<Self::Item> {
+        if self.next < self.vec.len {
+            // SAFETY: len must be non-zero as next is less than len.
+            let item = unsafe { self.vec.pop_unchecked() };
+            Some(item)
+        } else {
+            None
+        }
+    }
+}
+
+impl<T, LenT: LenType, const N: usize> FusedIterator for IntoIter<T, N, LenT> {}
+
+impl<T, LenT: LenType, const N: usize> ExactSizeIterator for IntoIter<T, N, LenT> {
+    fn len(&self) -> usize {
+        (self.vec.len - self.next).into_usize()
+    }
 }
 
 impl<T, LenT: LenType, const N: usize> Clone for IntoIter<T, N, LenT>
@@ -2034,6 +2060,32 @@ mod tests {
         assert_eq!(Droppable::count(), 0);
     }
 
+    #[test]
+    fn iter_move_next_back() {
+        let mut vec: Vec<&str, 3> = Vec::new();
+        vec.push("a").unwrap();
+        vec.push("b").unwrap();
+        vec.push("c").unwrap();
+        let mut items = vec.into_iter();
+        let _ = items.next(); // Remove the first item.
+        assert_eq!(items.next_back(), Some("c"));
+        assert_eq!(items.next_back(), Some("b"));
+        assert_eq!(items.next_back(), None);
+    }
+
+    #[test]
+    fn iter_move_len() {
+        let mut vec: Vec<&str, 2> = Vec::new();
+        vec.push("a").unwrap();
+        vec.push("b").unwrap();
+        let mut items = vec.into_iter();
+        assert_eq!(items.len(), 2);
+        let _ = items.next(); // Remove the first item.
+        assert_eq!(items.len(), 1);
+        let _ = items.next_back(); // Remove the last item.
+        assert_eq!(items.len(), 0);
+    }
+
     #[test]
     fn push_and_pop() {
         let mut v: Vec<i32, 4> = Vec::new();
