Specialize len for ExactSizeIterator with unmistakable size_hint

Author: ssomers

library/alloc/src/collections/binary_heap.rs

@@ -1342,6 +1342,10 @@ impl<'a, T> DoubleEndedIterator for Iter<'a, T> {
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T> ExactSizeIterator for Iter<'_, T> {
+    fn len(&self) -> usize {
+        self.iter.len()
+    }
+
     fn is_empty(&self) -> bool {
         self.iter.is_empty()
     }
@@ -1395,6 +1399,10 @@ impl<T> DoubleEndedIterator for IntoIter<T> {
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T> ExactSizeIterator for IntoIter<T> {
+    fn len(&self) -> usize {
+        self.iter.len()
+    }
+
     fn is_empty(&self) -> bool {
         self.iter.is_empty()
     }
@@ -1452,7 +1460,11 @@ impl<T: Ord> Iterator for IntoIterSorted<T> {
 }
 
 #[unstable(feature = "binary_heap_into_iter_sorted", issue = "59278")]
-impl<T: Ord> ExactSizeIterator for IntoIterSorted<T> {}
+impl<T: Ord> ExactSizeIterator for IntoIterSorted<T> {
+    fn len(&self) -> usize {
+        self.inner.len()
+    }
+}
 
 #[unstable(feature = "binary_heap_into_iter_sorted", issue = "59278")]
 impl<T: Ord> FusedIterator for IntoIterSorted<T> {}
@@ -1497,6 +1509,10 @@ impl<T> DoubleEndedIterator for Drain<'_, T> {
 
 #[stable(feature = "drain", since = "1.6.0")]
 impl<T> ExactSizeIterator for Drain<'_, T> {
+    fn len(&self) -> usize {
+        self.iter.len()
+    }
+
     fn is_empty(&self) -> bool {
         self.iter.is_empty()
     }
@@ -1554,7 +1570,11 @@ impl<T: Ord> Iterator for DrainSorted<'_, T> {
 }
 
 #[unstable(feature = "binary_heap_drain_sorted", issue = "59278")]
-impl<T: Ord> ExactSizeIterator for DrainSorted<'_, T> {}
+impl<T: Ord> ExactSizeIterator for DrainSorted<'_, T> {
+    fn len(&self) -> usize {
+        self.inner.len()
+    }
+}
 
 #[unstable(feature = "binary_heap_drain_sorted", issue = "59278")]
 impl<T: Ord> FusedIterator for DrainSorted<'_, T> {}

library/alloc/src/collections/linked_list.rs

@@ -1070,7 +1070,12 @@ impl<'a, T> DoubleEndedIterator for Iter<'a, T> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T> ExactSizeIterator for Iter<'_, T> {}
+impl<T> ExactSizeIterator for Iter<'_, T> {
+    #[inline]
+    fn len(&self) -> usize {
+        self.len
+    }
+}
 
 #[stable(feature = "fused", since = "1.26.0")]
 impl<T> FusedIterator for Iter<'_, T> {}
@@ -1124,7 +1129,11 @@ impl<'a, T> DoubleEndedIterator for IterMut<'a, T> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T> ExactSizeIterator for IterMut<'_, T> {}
+impl<T> ExactSizeIterator for IterMut<'_, T> {
+    fn len(&self) -> usize {
+        self.len
+    }
+}
 
 #[stable(feature = "fused", since = "1.26.0")]
 impl<T> FusedIterator for IterMut<'_, T> {}
@@ -1803,7 +1812,11 @@ impl<T> DoubleEndedIterator for IntoIter<T> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T> ExactSizeIterator for IntoIter<T> {}
+impl<T> ExactSizeIterator for IntoIter<T> {
+    fn len(&self) -> usize {
+        self.list.len
+    }
+}
 
 #[stable(feature = "fused", since = "1.26.0")]
 impl<T> FusedIterator for IntoIter<T> {}

library/alloc/src/collections/vec_deque/drain.rs

@@ -136,7 +136,14 @@ impl<T, A: Allocator> DoubleEndedIterator for Drain<'_, T, A> {
 }
 
 #[stable(feature = "drain", since = "1.6.0")]
-impl<T, A: Allocator> ExactSizeIterator for Drain<'_, T, A> {}
+impl<T, A: Allocator> ExactSizeIterator for Drain<'_, T, A> {
+    #[inline]
+    fn len(&self) -> usize {
+        let n = self.iter.len();
+        debug_assert_eq!(self.size_hint(), (n, Some(n)));
+        n
+    }
+}
 
 #[stable(feature = "fused", since = "1.26.0")]
 impl<T, A: Allocator> FusedIterator for Drain<'_, T, A> {}

library/alloc/src/collections/vec_deque/into_iter.rs

@@ -60,6 +60,11 @@ impl<T, A: Allocator> DoubleEndedIterator for IntoIter<T, A> {
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T, A: Allocator> ExactSizeIterator for IntoIter<T, A> {
+    #[inline]
+    fn len(&self) -> usize {
+        self.inner.len()
+    }
+
     fn is_empty(&self) -> bool {
         self.inner.is_empty()
     }

library/alloc/src/collections/vec_deque/iter.rs

@@ -67,7 +67,7 @@ impl<'a, T> Iterator for Iter<'a, T> {
 
     #[inline]
     fn size_hint(&self) -> (usize, Option<usize>) {
-        let len = count(self.tail, self.head, self.ring.len());
+        let len = self.len();
         (len, Some(len))
     }
 
@@ -113,7 +113,7 @@ impl<'a, T> Iterator for Iter<'a, T> {
     }
 
     fn nth(&mut self, n: usize) -> Option<Self::Item> {
-        if n >= count(self.tail, self.head, self.ring.len()) {
+        if n >= self.len() {
             self.tail = self.head;
             None
         } else {
@@ -197,6 +197,11 @@ impl<'a, T> DoubleEndedIterator for Iter<'a, T> {
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T> ExactSizeIterator for Iter<'_, T> {
+    #[inline]
+    fn len(&self) -> usize {
+        count(self.tail, self.head, self.ring.len())
+    }
+
     fn is_empty(&self) -> bool {
         self.head == self.tail
     }

library/alloc/src/collections/vec_deque/iter_mut.rs

@@ -68,7 +68,7 @@ impl<'a, T> Iterator for IterMut<'a, T> {
 
     #[inline]
     fn size_hint(&self) -> (usize, Option<usize>) {
-        let len = count(self.tail, self.head, self.ring.len());
+        let len = self.len();
         (len, Some(len))
     }
 
@@ -85,7 +85,7 @@ impl<'a, T> Iterator for IterMut<'a, T> {
     }
 
     fn nth(&mut self, n: usize) -> Option<Self::Item> {
-        if n >= count(self.tail, self.head, self.ring.len()) {
+        if n >= self.len() {
             self.tail = self.head;
             None
         } else {
@@ -140,6 +140,11 @@ impl<'a, T> DoubleEndedIterator for IterMut<'a, T> {
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T> ExactSizeIterator for IterMut<'_, T> {
+    #[inline]
+    fn len(&self) -> usize {
+        count(self.tail, self.head, self.ring.len())
+    }
+
     fn is_empty(&self) -> bool {
         self.head == self.tail
     }

library/alloc/src/vec/drain.rs

@@ -172,6 +172,10 @@ impl<T, A: Allocator> Drop for Drain<'_, T, A> {
 
 #[stable(feature = "drain", since = "1.6.0")]
 impl<T, A: Allocator> ExactSizeIterator for Drain<'_, T, A> {
+    fn len(&self) -> usize {
+        self.iter.len()
+    }
+
     fn is_empty(&self) -> bool {
         self.iter.is_empty()
     }

library/alloc/src/vec/into_iter.rs

@@ -166,11 +166,7 @@ impl<T, A: Allocator> Iterator for IntoIter<T, A> {
 
     #[inline]
     fn size_hint(&self) -> (usize, Option<usize>) {
-        let exact = if mem::size_of::<T>() == 0 {
-            self.end.addr().wrapping_sub(self.ptr.addr())
-        } else {
-            unsafe { self.end.sub_ptr(self.ptr) }
-        };
+        let exact = self.len();
         (exact, Some(exact))
     }
 
@@ -265,6 +261,15 @@ impl<T, A: Allocator> DoubleEndedIterator for IntoIter<T, A> {
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T, A: Allocator> ExactSizeIterator for IntoIter<T, A> {
+    #[inline]
+    fn len(&self) -> usize {
+        if mem::size_of::<T>() == 0 {
+            self.end.addr().wrapping_sub(self.ptr.addr())
+        } else {
+            unsafe { self.end.sub_ptr(self.ptr) }
+        }
+    }
+
     fn is_empty(&self) -> bool {
         self.ptr == self.end
     }

library/alloc/src/vec/splice.rs

@@ -48,7 +48,13 @@ impl<I: Iterator, A: Allocator> DoubleEndedIterator for Splice<'_, I, A> {
 }
 
 #[stable(feature = "vec_splice", since = "1.21.0")]
-impl<I: Iterator, A: Allocator> ExactSizeIterator for Splice<'_, I, A> {}
+impl<I: Iterator, A: Allocator> ExactSizeIterator for Splice<'_, I, A> {
+    fn len(&self) -> usize {
+        let n = self.drain.len();
+        debug_assert_eq!(self.size_hint(), (n, Some(n)));
+        n
+    }
+}
 
 #[stable(feature = "vec_splice", since = "1.21.0")]
 impl<I: Iterator, A: Allocator> Drop for Splice<'_, I, A> {

library/core/src/ascii.rs

@@ -129,7 +129,11 @@ impl DoubleEndedIterator for EscapeDefault {
     }
 }
 #[stable(feature = "rust1", since = "1.0.0")]
-impl ExactSizeIterator for EscapeDefault {}
+impl ExactSizeIterator for EscapeDefault {
+    fn len(&self) -> usize {
+        self.range.len()
+    }
+}
 #[stable(feature = "fused", since = "1.26.0")]
 impl FusedIterator for EscapeDefault {}
 

library/core/src/char/mod.rs

@@ -386,7 +386,13 @@ impl Iterator for EscapeDebug {
 }
 
 #[stable(feature = "char_escape_debug", since = "1.20.0")]
-impl ExactSizeIterator for EscapeDebug {}
+impl ExactSizeIterator for EscapeDebug {
+    fn len(&self) -> usize {
+        let n = self.0.len();
+        debug_assert_eq!(self.size_hint(), (n, Some(n)));
+        n
+    }
+}
 
 #[stable(feature = "fused", since = "1.26.0")]
 impl FusedIterator for EscapeDebug {}
@@ -430,7 +436,13 @@ impl DoubleEndedIterator for ToLowercase {
 impl FusedIterator for ToLowercase {}
 
 #[stable(feature = "exact_size_case_mapping_iter", since = "1.35.0")]
-impl ExactSizeIterator for ToLowercase {}
+impl ExactSizeIterator for ToLowercase {
+    fn len(&self) -> usize {
+        let n = self.0.len();
+        debug_assert_eq!(self.size_hint(), (n, Some(n)));
+        n
+    }
+}
 
 /// Returns an iterator that yields the uppercase equivalent of a `char`.
 ///
@@ -464,7 +476,13 @@ impl DoubleEndedIterator for ToUppercase {
 impl FusedIterator for ToUppercase {}
 
 #[stable(feature = "exact_size_case_mapping_iter", since = "1.35.0")]
-impl ExactSizeIterator for ToUppercase {}
+impl ExactSizeIterator for ToUppercase {
+    fn len(&self) -> usize {
+        let n = self.0.len();
+        debug_assert_eq!(self.size_hint(), (n, Some(n)));
+        n
+    }
+}
 
 #[derive(Debug, Clone)]
 enum CaseMappingIter {
@@ -509,13 +527,19 @@ impl Iterator for CaseMappingIter {
     }
 
     fn size_hint(&self) -> (usize, Option<usize>) {
-        let size = match self {
+        let size = self.len();
+        (size, Some(size))
+    }
+}
+
+impl CaseMappingIter {
+    fn len(&self) -> usize {
+        match self {
             CaseMappingIter::Three(..) => 3,
             CaseMappingIter::Two(..) => 2,
             CaseMappingIter::One(_) => 1,
             CaseMappingIter::Zero => 0,
-        };
-        (size, Some(size))
+        }
     }
 }
 

library/core/src/iter/traits/exact_size.rs

@@ -102,9 +102,9 @@ pub trait ExactSizeIterator: Iterator {
     fn len(&self) -> usize {
         let (lower, upper) = self.size_hint();
         // Note: This assertion is overly defensive, but it checks the invariant
-        // guaranteed by the trait. If this trait were rust-internal,
-        // we could use debug_assert!; assert_eq! will check all Rust user
-        // implementations too.
+        // guaranteed by the trait in all Rust user implementations too.
+        // If this trait were rust-internal, we could use debug_assert!, but
+        // any implementation for which it matters can override `len`.
         assert_eq!(upper, Some(lower));
         lower
     }

library/core/src/option.rs

@@ -2049,10 +2049,8 @@ impl<A> Iterator for Item<A> {
 
     #[inline]
     fn size_hint(&self) -> (usize, Option<usize>) {
-        match self.opt {
-            Some(_) => (1, Some(1)),
-            None => (0, Some(0)),
-        }
+        let exact = self.len();
+        (exact, Some(exact))
     }
 }
 
@@ -2063,7 +2061,16 @@ impl<A> DoubleEndedIterator for Item<A> {
     }
 }
 
-impl<A> ExactSizeIterator for Item<A> {}
+impl<A> ExactSizeIterator for Item<A> {
+    #[inline]
+    fn len(&self) -> usize {
+        match self.opt {
+            Some(_) => 1,
+            None => 0,
+        }
+    }
+}
+
 impl<A> FusedIterator for Item<A> {}
 unsafe impl<A> TrustedLen for Item<A> {}
 
@@ -2101,7 +2108,14 @@ impl<'a, A> DoubleEndedIterator for Iter<'a, A> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<A> ExactSizeIterator for Iter<'_, A> {}
+impl<A> ExactSizeIterator for Iter<'_, A> {
+    #[inline]
+    fn len(&self) -> usize {
+        let n = self.inner.len();
+        debug_assert_eq!(self.size_hint(), (n, Some(n)));
+        n
+    }
+}
 
 #[stable(feature = "fused", since = "1.26.0")]
 impl<A> FusedIterator for Iter<'_, A> {}
@@ -2151,7 +2165,14 @@ impl<'a, A> DoubleEndedIterator for IterMut<'a, A> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<A> ExactSizeIterator for IterMut<'_, A> {}
+impl<A> ExactSizeIterator for IterMut<'_, A> {
+    #[inline]
+    fn len(&self) -> usize {
+        let n = self.inner.len();
+        debug_assert_eq!(self.size_hint(), (n, Some(n)));
+        n
+    }
+}
 
 #[stable(feature = "fused", since = "1.26.0")]
 impl<A> FusedIterator for IterMut<'_, A> {}
@@ -2192,7 +2213,14 @@ impl<A> DoubleEndedIterator for IntoIter<A> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<A> ExactSizeIterator for IntoIter<A> {}
+impl<A> ExactSizeIterator for IntoIter<A> {
+    #[inline]
+    fn len(&self) -> usize {
+        let n = self.inner.len();
+        debug_assert_eq!(self.size_hint(), (n, Some(n)));
+        n
+    }
+}
 
 #[stable(feature = "fused", since = "1.26.0")]
 impl<A> FusedIterator for IntoIter<A> {}

library/core/src/result.rs

@@ -1919,7 +1919,7 @@ impl<'a, T> Iterator for Iter<'a, T> {
     }
     #[inline]
     fn size_hint(&self) -> (usize, Option<usize>) {
-        let n = if self.inner.is_some() { 1 } else { 0 };
+        let n = self.len();
         (n, Some(n))
     }
 }
@@ -1933,7 +1933,12 @@ impl<'a, T> DoubleEndedIterator for Iter<'a, T> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T> ExactSizeIterator for Iter<'_, T> {}
+impl<T> ExactSizeIterator for Iter<'_, T> {
+    #[inline]
+    fn len(&self) -> usize {
+        if self.inner.is_some() { 1 } else { 0 }
+    }
+}
 
 #[stable(feature = "fused", since = "1.26.0")]
 impl<T> FusedIterator for Iter<'_, T> {}
@@ -1968,7 +1973,7 @@ impl<'a, T> Iterator for IterMut<'a, T> {
     }
     #[inline]
     fn size_hint(&self) -> (usize, Option<usize>) {
-        let n = if self.inner.is_some() { 1 } else { 0 };
+        let n = self.len();
         (n, Some(n))
     }
 }
@@ -1982,7 +1987,12 @@ impl<'a, T> DoubleEndedIterator for IterMut<'a, T> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T> ExactSizeIterator for IterMut<'_, T> {}
+impl<T> ExactSizeIterator for IterMut<'_, T> {
+    #[inline]
+    fn len(&self) -> usize {
+        if self.inner.is_some() { 1 } else { 0 }
+    }
+}
 
 #[stable(feature = "fused", since = "1.26.0")]
 impl<T> FusedIterator for IterMut<'_, T> {}
@@ -2014,7 +2024,7 @@ impl<T> Iterator for IntoIter<T> {
     }
     #[inline]
     fn size_hint(&self) -> (usize, Option<usize>) {
-        let n = if self.inner.is_some() { 1 } else { 0 };
+        let n = self.len();
         (n, Some(n))
     }
 }
@@ -2028,7 +2038,12 @@ impl<T> DoubleEndedIterator for IntoIter<T> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T> ExactSizeIterator for IntoIter<T> {}
+impl<T> ExactSizeIterator for IntoIter<T> {
+    #[inline]
+    fn len(&self) -> usize {
+        if self.inner.is_some() { 1 } else { 0 }
+    }
+}
 
 #[stable(feature = "fused", since = "1.26.0")]
 impl<T> FusedIterator for IntoIter<T> {}

library/core/src/slice/iter.rs

@@ -1334,12 +1334,8 @@ impl<'a, T> Iterator for Windows<'a, T> {
 
     #[inline]
     fn size_hint(&self) -> (usize, Option<usize>) {
-        if self.size.get() > self.v.len() {
-            (0, Some(0))
-        } else {
-            let size = self.v.len() - self.size.get() + 1;
-            (size, Some(size))
-        }
+        let size = self.len();
+        (size, Some(size))
     }
 
     #[inline]
@@ -1407,7 +1403,12 @@ impl<'a, T> DoubleEndedIterator for Windows<'a, T> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T> ExactSizeIterator for Windows<'_, T> {}
+impl<T> ExactSizeIterator for Windows<'_, T> {
+    #[inline]
+    fn len(&self) -> usize {
+        if self.size.get() > self.v.len() { 0 } else { self.v.len() - self.size.get() + 1 }
+    }
+}
 
 #[unstable(feature = "trusted_len", issue = "37572")]
 unsafe impl<T> TrustedLen for Windows<'_, T> {}
@@ -1483,14 +1484,8 @@ impl<'a, T> Iterator for Chunks<'a, T> {
 
     #[inline]
     fn size_hint(&self) -> (usize, Option<usize>) {
-        if self.v.is_empty() {
-            (0, Some(0))
-        } else {
-            let n = self.v.len() / self.chunk_size;
-            let rem = self.v.len() % self.chunk_size;
-            let n = if rem > 0 { n + 1 } else { n };
-            (n, Some(n))
-        }
+        let n = self.len();
+        (n, Some(n))
     }
 
     #[inline]
@@ -1590,7 +1585,18 @@ impl<'a, T> DoubleEndedIterator for Chunks<'a, T> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T> ExactSizeIterator for Chunks<'_, T> {}
+impl<T> ExactSizeIterator for Chunks<'_, T> {
+    #[inline]
+    fn len(&self) -> usize {
+        if self.v.is_empty() {
+            0
+        } else {
+            let n = self.v.len() / self.chunk_size;
+            let rem = self.v.len() % self.chunk_size;
+            if rem > 0 { n + 1 } else { n }
+        }
+    }
+}
 
 #[unstable(feature = "trusted_len", issue = "37572")]
 unsafe impl<T> TrustedLen for Chunks<'_, T> {}
@@ -1659,14 +1665,8 @@ impl<'a, T> Iterator for ChunksMut<'a, T> {
 
     #[inline]
     fn size_hint(&self) -> (usize, Option<usize>) {
-        if self.v.is_empty() {
-            (0, Some(0))
-        } else {
-            let n = self.v.len() / self.chunk_size;
-            let rem = self.v.len() % self.chunk_size;
-            let n = if rem > 0 { n + 1 } else { n };
-            (n, Some(n))
-        }
+        let n = self.len();
+        (n, Some(n))
     }
 
     #[inline]
@@ -1757,7 +1757,18 @@ impl<'a, T> DoubleEndedIterator for ChunksMut<'a, T> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T> ExactSizeIterator for ChunksMut<'_, T> {}
+impl<T> ExactSizeIterator for ChunksMut<'_, T> {
+    #[inline]
+    fn len(&self) -> usize {
+        if self.v.is_empty() {
+            0
+        } else {
+            let n = self.v.len() / self.chunk_size;
+            let rem = self.v.len() % self.chunk_size;
+            if rem > 0 { n + 1 } else { n }
+        }
+    }
+}
 
 #[unstable(feature = "trusted_len", issue = "37572")]
 unsafe impl<T> TrustedLen for ChunksMut<'_, T> {}
@@ -1848,7 +1859,7 @@ impl<'a, T> Iterator for ChunksExact<'a, T> {
 
     #[inline]
     fn size_hint(&self) -> (usize, Option<usize>) {
-        let n = self.v.len() / self.chunk_size;
+        let n = self.len();
         (n, Some(n))
     }
 
@@ -1913,6 +1924,11 @@ impl<'a, T> DoubleEndedIterator for ChunksExact<'a, T> {
 
 #[stable(feature = "chunks_exact", since = "1.31.0")]
 impl<T> ExactSizeIterator for ChunksExact<'_, T> {
+    #[inline]
+    fn len(&self) -> usize {
+        self.v.len() / self.chunk_size
+    }
+
     fn is_empty(&self) -> bool {
         self.v.is_empty()
     }
@@ -2000,7 +2016,7 @@ impl<'a, T> Iterator for ChunksExactMut<'a, T> {
 
     #[inline]
     fn size_hint(&self) -> (usize, Option<usize>) {
-        let n = self.v.len() / self.chunk_size;
+        let n = self.len();
         (n, Some(n))
     }
 
@@ -2069,6 +2085,11 @@ impl<'a, T> DoubleEndedIterator for ChunksExactMut<'a, T> {
 
 #[stable(feature = "chunks_exact", since = "1.31.0")]
 impl<T> ExactSizeIterator for ChunksExactMut<'_, T> {
+    #[inline]
+    fn len(&self) -> usize {
+        self.v.len() / self.chunk_size
+    }
+
     fn is_empty(&self) -> bool {
         self.v.is_empty()
     }
@@ -2203,8 +2224,9 @@ impl<'a, T, const N: usize> DoubleEndedIterator for ArrayWindows<'a, T, N> {
 
 #[unstable(feature = "array_windows", issue = "75027")]
 impl<T, const N: usize> ExactSizeIterator for ArrayWindows<'_, T, N> {
-    fn is_empty(&self) -> bool {
-        self.num == 0
+    #[inline]
+    fn len(&self) -> usize {
+        self.num
     }
 }
 
@@ -2313,6 +2335,13 @@ impl<'a, T, const N: usize> DoubleEndedIterator for ArrayChunks<'a, T, N> {
 
 #[unstable(feature = "array_chunks", issue = "74985")]
 impl<T, const N: usize> ExactSizeIterator for ArrayChunks<'_, T, N> {
+    #[inline]
+    fn len(&self) -> usize {
+        let n = self.iter.len();
+        debug_assert_eq!(self.size_hint(), (n, Some(n)));
+        n
+    }
+
     fn is_empty(&self) -> bool {
         self.iter.is_empty()
     }
@@ -2431,6 +2460,13 @@ impl<'a, T, const N: usize> DoubleEndedIterator for ArrayChunksMut<'a, T, N> {
 
 #[unstable(feature = "array_chunks", issue = "74985")]
 impl<T, const N: usize> ExactSizeIterator for ArrayChunksMut<'_, T, N> {
+    #[inline]
+    fn len(&self) -> usize {
+        let n = self.iter.len();
+        debug_assert_eq!(self.size_hint(), (n, Some(n)));
+        n
+    }
+
     fn is_empty(&self) -> bool {
         self.iter.is_empty()
     }
@@ -2516,14 +2552,8 @@ impl<'a, T> Iterator for RChunks<'a, T> {
 
     #[inline]
     fn size_hint(&self) -> (usize, Option<usize>) {
-        if self.v.is_empty() {
-            (0, Some(0))
-        } else {
-            let n = self.v.len() / self.chunk_size;
-            let rem = self.v.len() % self.chunk_size;
-            let n = if rem > 0 { n + 1 } else { n };
-            (n, Some(n))
-        }
+        let n = self.len();
+        (n, Some(n))
     }
 
     #[inline]
@@ -2607,7 +2637,18 @@ impl<'a, T> DoubleEndedIterator for RChunks<'a, T> {
 }
 
 #[stable(feature = "rchunks", since = "1.31.0")]
-impl<T> ExactSizeIterator for RChunks<'_, T> {}
+impl<T> ExactSizeIterator for RChunks<'_, T> {
+    #[inline]
+    fn len(&self) -> usize {
+        if self.v.is_empty() {
+            0
+        } else {
+            let n = self.v.len() / self.chunk_size;
+            let rem = self.v.len() % self.chunk_size;
+            if rem > 0 { n + 1 } else { n }
+        }
+    }
+}
 
 #[unstable(feature = "trusted_len", issue = "37572")]
 unsafe impl<T> TrustedLen for RChunks<'_, T> {}
@@ -2682,14 +2723,8 @@ impl<'a, T> Iterator for RChunksMut<'a, T> {
 
     #[inline]
     fn size_hint(&self) -> (usize, Option<usize>) {
-        if self.v.is_empty() {
-            (0, Some(0))
-        } else {
-            let n = self.v.len() / self.chunk_size;
-            let rem = self.v.len() % self.chunk_size;
-            let n = if rem > 0 { n + 1 } else { n };
-            (n, Some(n))
-        }
+        let n = self.len();
+        (n, Some(n))
     }
 
     #[inline]
@@ -2778,7 +2813,18 @@ impl<'a, T> DoubleEndedIterator for RChunksMut<'a, T> {
 }
 
 #[stable(feature = "rchunks", since = "1.31.0")]
-impl<T> ExactSizeIterator for RChunksMut<'_, T> {}
+impl<T> ExactSizeIterator for RChunksMut<'_, T> {
+    #[inline]
+    fn len(&self) -> usize {
+        if self.v.is_empty() {
+            0
+        } else {
+            let n = self.v.len() / self.chunk_size;
+            let rem = self.v.len() % self.chunk_size;
+            if rem > 0 { n + 1 } else { n }
+        }
+    }
+}
 
 #[unstable(feature = "trusted_len", issue = "37572")]
 unsafe impl<T> TrustedLen for RChunksMut<'_, T> {}
@@ -2868,7 +2914,7 @@ impl<'a, T> Iterator for RChunksExact<'a, T> {
 
     #[inline]
     fn size_hint(&self) -> (usize, Option<usize>) {
-        let n = self.v.len() / self.chunk_size;
+        let n = self.len();
         (n, Some(n))
     }
 
@@ -2938,6 +2984,11 @@ impl<'a, T> DoubleEndedIterator for RChunksExact<'a, T> {
 
 #[stable(feature = "rchunks", since = "1.31.0")]
 impl<'a, T> ExactSizeIterator for RChunksExact<'a, T> {
+    #[inline]
+    fn len(&self) -> usize {
+        self.v.len() / self.chunk_size
+    }
+
     fn is_empty(&self) -> bool {
         self.v.is_empty()
     }
@@ -3025,7 +3076,7 @@ impl<'a, T> Iterator for RChunksExactMut<'a, T> {
 
     #[inline]
     fn size_hint(&self) -> (usize, Option<usize>) {
-        let n = self.v.len() / self.chunk_size;
+        let n = self.len();
         (n, Some(n))
     }
 
@@ -3098,6 +3149,11 @@ impl<'a, T> DoubleEndedIterator for RChunksExactMut<'a, T> {
 
 #[stable(feature = "rchunks", since = "1.31.0")]
 impl<T> ExactSizeIterator for RChunksExactMut<'_, T> {
+    #[inline]
+    fn len(&self) -> usize {
+        self.v.len() / self.chunk_size
+    }
+
     fn is_empty(&self) -> bool {
         self.v.is_empty()
     }