Add implementations of last in terms of next_back on a bunch of DoubleEndedIterators.

khuey · khuey · commit 3e86cf36b511 · 2019-04-19T21:52:43.000-07:00
r?Manishearth
diff --git a/src/liballoc/collections/binary_heap.rs b/src/liballoc/collections/binary_heap.rs
@@ -968,6 +968,11 @@ impl<'a, T> Iterator for Iter<'a, T> {
     fn size_hint(&self) -> (usize, Option<usize>) {
         self.iter.size_hint()
     }
+
+    #[inline]
+    fn last(mut self) -> Option<&'a T> {
+        self.next_back()
+    }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -1023,6 +1028,11 @@ impl<T> Iterator for IntoIter<T> {
     fn size_hint(&self) -> (usize, Option<usize>) {
         self.iter.size_hint()
     }
+
+    #[inline]
+    fn last(mut self) -> Option<T> {
+        self.next_back()
+    }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -1069,6 +1079,11 @@ impl<T> Iterator for Drain<'_, T> {
     fn size_hint(&self) -> (usize, Option<usize>) {
         self.iter.size_hint()
     }
+
+    #[inline]
+    fn last(mut self) -> Option<T> {
+        self.next_back()
+    }
 }
 
 #[stable(feature = "drain", since = "1.6.0")]
diff --git a/src/liballoc/collections/btree/map.rs b/src/liballoc/collections/btree/map.rs
@@ -1193,6 +1193,11 @@ impl<'a, K: 'a, V: 'a> Iterator for Iter<'a, K, V> {
     fn size_hint(&self) -> (usize, Option<usize>) {
         (self.length, Some(self.length))
     }
+
+    #[inline]
+    fn last(mut self) -> Option<(&'a K, &'a V)> {
+        self.next_back()
+    }
 }
 
 #[stable(feature = "fused", since = "1.26.0")]
@@ -1253,6 +1258,11 @@ impl<'a, K: 'a, V: 'a> Iterator for IterMut<'a, K, V> {
     fn size_hint(&self) -> (usize, Option<usize>) {
         (self.length, Some(self.length))
     }
+
+    #[inline]
+    fn last(mut self) -> Option<(&'a K, &'a mut V)> {
+        self.next_back()
+    }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -1359,6 +1369,11 @@ impl<K, V> Iterator for IntoIter<K, V> {
     fn size_hint(&self) -> (usize, Option<usize>) {
         (self.length, Some(self.length))
     }
+
+    #[inline]
+    fn last(mut self) -> Option<(K, V)> {
+        self.next_back()
+    }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -1421,6 +1436,11 @@ impl<'a, K, V> Iterator for Keys<'a, K, V> {
     fn size_hint(&self) -> (usize, Option<usize>) {
         self.inner.size_hint()
     }
+
+    #[inline]
+    fn last(mut self) -> Option<&'a K> {
+        self.next_back()
+    }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -1458,6 +1478,11 @@ impl<'a, K, V> Iterator for Values<'a, K, V> {
     fn size_hint(&self) -> (usize, Option<usize>) {
         self.inner.size_hint()
     }
+
+    #[inline]
+    fn last(mut self) -> Option<&'a V> {
+        self.next_back()
+    }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -1495,6 +1520,11 @@ impl<'a, K, V> Iterator for Range<'a, K, V> {
             unsafe { Some(self.next_unchecked()) }
         }
     }
+
+    #[inline]
+    fn last(mut self) -> Option<(&'a K, &'a V)> {
+        self.next_back()
+    }
 }
 
 #[stable(feature = "map_values_mut", since = "1.10.0")]
@@ -1508,6 +1538,11 @@ impl<'a, K, V> Iterator for ValuesMut<'a, K, V> {
     fn size_hint(&self) -> (usize, Option<usize>) {
         self.inner.size_hint()
     }
+
+    #[inline]
+    fn last(mut self) -> Option<&'a mut V> {
+        self.next_back()
+    }
 }
 
 #[stable(feature = "map_values_mut", since = "1.10.0")]
@@ -1626,6 +1661,11 @@ impl<'a, K, V> Iterator for RangeMut<'a, K, V> {
             unsafe { Some(self.next_unchecked()) }
         }
     }
+
+    #[inline]
+    fn last(mut self) -> Option<(&'a K, &'a mut V)> {
+        self.next_back()
+    }
 }
 
 impl<'a, K, V> RangeMut<'a, K, V> {
diff --git a/src/liballoc/collections/btree/set.rs b/src/liballoc/collections/btree/set.rs
@@ -1019,6 +1019,11 @@ impl<'a, T> Iterator for Iter<'a, T> {
     fn size_hint(&self) -> (usize, Option<usize>) {
         self.iter.size_hint()
     }
+
+    #[inline]
+    fn last(mut self) -> Option<&'a T> {
+        self.next_back()
+    }
 }
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<'a, T> DoubleEndedIterator for Iter<'a, T> {
@@ -1044,6 +1049,11 @@ impl<T> Iterator for IntoIter<T> {
     fn size_hint(&self) -> (usize, Option<usize>) {
         self.iter.size_hint()
     }
+
+    #[inline]
+    fn last(mut self) -> Option<T> {
+        self.next_back()
+    }
 }
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T> DoubleEndedIterator for IntoIter<T> {
@@ -1073,6 +1083,11 @@ impl<'a, T> Iterator for Range<'a, T> {
     fn next(&mut self) -> Option<&'a T> {
         self.iter.next().map(|(k, _)| k)
     }
+
+    #[inline]
+    fn last(mut self) -> Option<&'a T> {
+        self.next_back()
+    }
 }
 
 #[stable(feature = "btree_range", since = "1.17.0")]
diff --git a/src/liballoc/string.rs b/src/liballoc/string.rs
@@ -2367,6 +2367,10 @@ impl Iterator for Drain<'_> {
     fn size_hint(&self) -> (usize, Option<usize>) {
         self.iter.size_hint()
     }
+    #[inline]
+    fn last(mut self) -> Option<char> {
+        self.next_back()
+    }
 }
 
 #[stable(feature = "drain", since = "1.6.0")]
diff --git a/src/liballoc/vec.rs b/src/liballoc/vec.rs
@@ -2385,6 +2385,11 @@ impl<T> Iterator for IntoIter<T> {
     fn count(self) -> usize {
         self.len()
     }
+
+    #[inline]
+    fn last(mut self) -> Option<T> {
+        self.next_back()
+    }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -2504,6 +2509,11 @@ impl<T> Iterator for Drain<'_, T> {
     fn size_hint(&self) -> (usize, Option<usize>) {
         self.iter.size_hint()
     }
+
+    #[inline]
+    fn last(mut self) -> Option<T> {
+        self.next_back()
+    }
 }
 
 #[stable(feature = "drain", since = "1.6.0")]
@@ -2573,6 +2583,10 @@ impl<I: Iterator> Iterator for Splice<'_, I> {
     fn size_hint(&self) -> (usize, Option<usize>) {
         self.drain.size_hint()
     }
+
+    fn last(mut self) -> Option<Self::Item> {
+        self.next_back()
+    }
 }
 
 #[stable(feature = "vec_splice", since = "1.21.0")]
diff --git a/src/libcore/ascii.rs b/src/libcore/ascii.rs
@@ -117,6 +117,8 @@ impl Iterator for EscapeDefault {
     type Item = u8;
     fn next(&mut self) -> Option<u8> { self.range.next().map(|i| self.data[i]) }
     fn size_hint(&self) -> (usize, Option<usize>) { self.range.size_hint() }
+    #[inline]
+    fn last(mut self) -> Option<u8> { self.next_back() }
 }
 #[stable(feature = "rust1", since = "1.0.0")]
 impl DoubleEndedIterator for EscapeDefault {
diff --git a/src/libcore/iter/adapters/mod.rs b/src/libcore/iter/adapters/mod.rs
@@ -73,6 +73,11 @@ impl<I> Iterator for Rev<I> where I: DoubleEndedIterator {
     {
         self.iter.position(predicate)
     }
+
+    #[inline]
+    fn last(mut self) -> Option<Self::Item> {
+        self.next_back()
+    }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
diff --git a/src/libcore/slice/mod.rs b/src/libcore/slice/mod.rs
@@ -3539,6 +3539,11 @@ impl<'a, T, P> Iterator for Split<'a, T, P> where P: FnMut(&T) -> bool {
             (1, Some(self.v.len() + 1))
         }
     }
+
+    #[inline]
+    fn last(mut self) -> Option<Self::Item> {
+        self.next_back()
+    }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -3637,6 +3642,11 @@ impl<'a, T, P> Iterator for SplitMut<'a, T, P> where P: FnMut(&T) -> bool {
             (1, Some(self.v.len() + 1))
         }
     }
+
+    #[inline]
+    fn last(mut self) -> Option<Self::Item> {
+        self.next_back()
+    }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -3702,6 +3712,11 @@ impl<'a, T, P> Iterator for RSplit<'a, T, P> where P: FnMut(&T) -> bool {
     fn size_hint(&self) -> (usize, Option<usize>) {
         self.inner.size_hint()
     }
+
+    #[inline]
+    fn last(mut self) -> Option<Self::Item> {
+        self.next_back()
+    }
 }
 
 #[stable(feature = "slice_rsplit", since = "1.27.0")]
@@ -3766,6 +3781,11 @@ impl<'a, T, P> Iterator for RSplitMut<'a, T, P> where P: FnMut(&T) -> bool {
     fn size_hint(&self) -> (usize, Option<usize>) {
         self.inner.size_hint()
     }
+
+    #[inline]
+    fn last(mut self) -> Option<Self::Item> {
+        self.next_back()
+    }
 }
 
 #[stable(feature = "slice_rsplit", since = "1.27.0")]
diff --git a/src/libcore/str/mod.rs b/src/libcore/str/mod.rs
@@ -1331,6 +1331,11 @@ impl<'a> Iterator for Lines<'a> {
     fn size_hint(&self) -> (usize, Option<usize>) {
         self.0.size_hint()
     }
+
+    #[inline]
+    fn last(mut self) -> Option<Self::Item> {
+        self.next_back()
+    }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -1377,6 +1382,11 @@ impl<'a> Iterator for LinesAny<'a> {
     fn size_hint(&self) -> (usize, Option<usize>) {
         self.0.size_hint()
     }
+
+    #[inline]
+    fn last(mut self) -> Option<Self::Item> {
+        self.next_back()
+    }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -4215,6 +4225,11 @@ impl<'a> Iterator for SplitWhitespace<'a> {
     fn size_hint(&self) -> (usize, Option<usize>) {
         self.inner.size_hint()
     }
+
+    #[inline]
+    fn last(mut self) -> Option<Self::Item> {
+        self.next_back()
+    }
 }
 
 #[stable(feature = "split_whitespace", since = "1.1.0")]
@@ -4241,6 +4256,11 @@ impl<'a> Iterator for SplitAsciiWhitespace<'a> {
     fn size_hint(&self) -> (usize, Option<usize>) {
         self.inner.size_hint()
     }
+
+    #[inline]
+    fn last(mut self) -> Option<Self::Item> {
+        self.next_back()
+    }
 }
 
 #[stable(feature = "split_ascii_whitespace", since = "1.34.0")]
diff --git a/src/libstd/env.rs b/src/libstd/env.rs
@@ -740,6 +740,10 @@ impl Iterator for Args {
         self.inner.next().map(|s| s.into_string().unwrap())
     }
     fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }
+    #[inline]
+    fn last(mut self) -> Option<String> {
+        self.next_back()
+    }
 }
 
 #[stable(feature = "env", since = "1.0.0")]
@@ -775,6 +779,8 @@ impl Iterator for ArgsOs {
     type Item = OsString;
     fn next(&mut self) -> Option<OsString> { self.inner.next() }
     fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }
+    #[inline]
+    fn last(mut self) -> Option<OsString> { self.next_back() }
 }
 
 #[stable(feature = "env", since = "1.0.0")]
diff --git a/src/libstd/path.rs b/src/libstd/path.rs
@@ -886,6 +886,11 @@ impl<'a> Iterator for Iter<'a> {
     fn next(&mut self) -> Option<&'a OsStr> {
         self.inner.next().map(Component::as_os_str)
     }
+
+    #[inline]
+    fn last(mut self) -> Option<&'a OsStr> {
+        self.next_back()
+    }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -949,6 +954,11 @@ impl<'a> Iterator for Components<'a> {
         }
         None
     }
+
+    #[inline]
+    fn last(mut self) -> Option<Self::Item> {
+        self.next_back()
+    }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
diff --git a/src/libstd/sys/unix/args.rs b/src/libstd/sys/unix/args.rs
@@ -35,6 +35,8 @@ impl Iterator for Args {
     type Item = OsString;
     fn next(&mut self) -> Option<OsString> { self.iter.next() }
     fn size_hint(&self) -> (usize, Option<usize>) { self.iter.size_hint() }
+    #[inline]
+    fn last(mut self) -> Option<OsString> { self.next_back() }
 }
 
 impl ExactSizeIterator for Args {
diff --git a/src/libstd/sys/wasm/args.rs b/src/libstd/sys/wasm/args.rs
@@ -37,6 +37,10 @@ impl Iterator for Args {
     fn size_hint(&self) -> (usize, Option<usize>) {
         self.iter.size_hint()
     }
+    #[inline]
+    fn last(mut self) -> Option<OsString> {
+        self.next_back()
+    }
 }
 
 impl ExactSizeIterator for Args {
diff --git a/src/libstd/sys/windows/args.rs b/src/libstd/sys/windows/args.rs

Original file line number	Diff line number	Diff line change
`@@ -968,6 +968,11 @@ impl<'a, T> Iterator for Iter<'a, T> {`
`968`	`968`	`fn size_hint(&self) -> (usize, Option<usize>) {`
`969`	`969`	`self.iter.size_hint()`
`970`	`970`	`}`
	`971`	`+`
	`972`	`+ #[inline]`
	`973`	`+ fn last(mut self) -> Option<&'a T> {`
	`974`	`+ self.next_back()`
	`975`	`+ }`
`971`	`976`	`}`
`972`	`977`
`973`	`978`	`#[stable(feature = "rust1", since = "1.0.0")]`
`@@ -1023,6 +1028,11 @@ impl<T> Iterator for IntoIter<T> {`
`1023`	`1028`	`fn size_hint(&self) -> (usize, Option<usize>) {`
`1024`	`1029`	`self.iter.size_hint()`
`1025`	`1030`	`}`
	`1031`	`+`
	`1032`	`+ #[inline]`
	`1033`	`+ fn last(mut self) -> Option<T> {`
	`1034`	`+ self.next_back()`
	`1035`	`+ }`
`1026`	`1036`	`}`
`1027`	`1037`
`1028`	`1038`	`#[stable(feature = "rust1", since = "1.0.0")]`
`@@ -1069,6 +1079,11 @@ impl<T> Iterator for Drain<'_, T> {`
`1069`	`1079`	`fn size_hint(&self) -> (usize, Option<usize>) {`
`1070`	`1080`	`self.iter.size_hint()`
`1071`	`1081`	`}`
	`1082`	`+`
	`1083`	`+ #[inline]`
	`1084`	`+ fn last(mut self) -> Option<T> {`
	`1085`	`+ self.next_back()`
	`1086`	`+ }`
`1072`	`1087`	`}`
`1073`	`1088`
`1074`	`1089`	`#[stable(feature = "drain", since = "1.6.0")]`
Original file line number	Diff line number	Diff line change
`@@ -1193,6 +1193,11 @@ impl<'a, K: 'a, V: 'a> Iterator for Iter<'a, K, V> {`
`1193`	`1193`	`fn size_hint(&self) -> (usize, Option<usize>) {`
`1194`	`1194`	`(self.length, Some(self.length))`
`1195`	`1195`	`}`
	`1196`	`+`
	`1197`	`+ #[inline]`
	`1198`	`+ fn last(mut self) -> Option<(&'a K, &'a V)> {`
	`1199`	`+ self.next_back()`
	`1200`	`+ }`
`1196`	`1201`	`}`
`1197`	`1202`
`1198`	`1203`	`#[stable(feature = "fused", since = "1.26.0")]`
`@@ -1253,6 +1258,11 @@ impl<'a, K: 'a, V: 'a> Iterator for IterMut<'a, K, V> {`
`1253`	`1258`	`fn size_hint(&self) -> (usize, Option<usize>) {`
`1254`	`1259`	`(self.length, Some(self.length))`
`1255`	`1260`	`}`
	`1261`	`+`
	`1262`	`+ #[inline]`
	`1263`	`+ fn last(mut self) -> Option<(&'a K, &'a mut V)> {`
	`1264`	`+ self.next_back()`
	`1265`	`+ }`
`1256`	`1266`	`}`
`1257`	`1267`
`1258`	`1268`	`#[stable(feature = "rust1", since = "1.0.0")]`
`@@ -1359,6 +1369,11 @@ impl<K, V> Iterator for IntoIter<K, V> {`
`1359`	`1369`	`fn size_hint(&self) -> (usize, Option<usize>) {`
`1360`	`1370`	`(self.length, Some(self.length))`
`1361`	`1371`	`}`
	`1372`	`+`
	`1373`	`+ #[inline]`
	`1374`	`+ fn last(mut self) -> Option<(K, V)> {`
	`1375`	`+ self.next_back()`
	`1376`	`+ }`
`1362`	`1377`	`}`
`1363`	`1378`
`1364`	`1379`	`#[stable(feature = "rust1", since = "1.0.0")]`
`@@ -1421,6 +1436,11 @@ impl<'a, K, V> Iterator for Keys<'a, K, V> {`
`1421`	`1436`	`fn size_hint(&self) -> (usize, Option<usize>) {`
`1422`	`1437`	`self.inner.size_hint()`
`1423`	`1438`	`}`
	`1439`	`+`
	`1440`	`+ #[inline]`
	`1441`	`+ fn last(mut self) -> Option<&'a K> {`
	`1442`	`+ self.next_back()`
	`1443`	`+ }`
`1424`	`1444`	`}`
`1425`	`1445`
`1426`	`1446`	`#[stable(feature = "rust1", since = "1.0.0")]`
`@@ -1458,6 +1478,11 @@ impl<'a, K, V> Iterator for Values<'a, K, V> {`
`1458`	`1478`	`fn size_hint(&self) -> (usize, Option<usize>) {`
`1459`	`1479`	`self.inner.size_hint()`
`1460`	`1480`	`}`
	`1481`	`+`
	`1482`	`+ #[inline]`
	`1483`	`+ fn last(mut self) -> Option<&'a V> {`
	`1484`	`+ self.next_back()`
	`1485`	`+ }`
`1461`	`1486`	`}`
`1462`	`1487`
`1463`	`1488`	`#[stable(feature = "rust1", since = "1.0.0")]`
`@@ -1495,6 +1520,11 @@ impl<'a, K, V> Iterator for Range<'a, K, V> {`
`1495`	`1520`	`unsafe { Some(self.next_unchecked()) }`
`1496`	`1521`	`}`
`1497`	`1522`	`}`
	`1523`	`+`
	`1524`	`+ #[inline]`
	`1525`	`+ fn last(mut self) -> Option<(&'a K, &'a V)> {`
	`1526`	`+ self.next_back()`
	`1527`	`+ }`
`1498`	`1528`	`}`
`1499`	`1529`
`1500`	`1530`	`#[stable(feature = "map_values_mut", since = "1.10.0")]`
`@@ -1508,6 +1538,11 @@ impl<'a, K, V> Iterator for ValuesMut<'a, K, V> {`
`1508`	`1538`	`fn size_hint(&self) -> (usize, Option<usize>) {`
`1509`	`1539`	`self.inner.size_hint()`
`1510`	`1540`	`}`
	`1541`	`+`
	`1542`	`+ #[inline]`
	`1543`	`+ fn last(mut self) -> Option<&'a mut V> {`
	`1544`	`+ self.next_back()`
	`1545`	`+ }`
`1511`	`1546`	`}`
`1512`	`1547`
`1513`	`1548`	`#[stable(feature = "map_values_mut", since = "1.10.0")]`
`@@ -1626,6 +1661,11 @@ impl<'a, K, V> Iterator for RangeMut<'a, K, V> {`
`1626`	`1661`	`unsafe { Some(self.next_unchecked()) }`
`1627`	`1662`	`}`
`1628`	`1663`	`}`
	`1664`	`+`
	`1665`	`+ #[inline]`
	`1666`	`+ fn last(mut self) -> Option<(&'a K, &'a mut V)> {`
	`1667`	`+ self.next_back()`
	`1668`	`+ }`
`1629`	`1669`	`}`
`1630`	`1670`
`1631`	`1671`	`impl<'a, K, V> RangeMut<'a, K, V> {`
Original file line number	Diff line number	Diff line change
`@@ -1019,6 +1019,11 @@ impl<'a, T> Iterator for Iter<'a, T> {`
`1019`	`1019`	`fn size_hint(&self) -> (usize, Option<usize>) {`
`1020`	`1020`	`self.iter.size_hint()`
`1021`	`1021`	`}`
	`1022`	`+`
	`1023`	`+ #[inline]`
	`1024`	`+ fn last(mut self) -> Option<&'a T> {`
	`1025`	`+ self.next_back()`
	`1026`	`+ }`
`1022`	`1027`	`}`
`1023`	`1028`	`#[stable(feature = "rust1", since = "1.0.0")]`
`1024`	`1029`	`impl<'a, T> DoubleEndedIterator for Iter<'a, T> {`
`@@ -1044,6 +1049,11 @@ impl<T> Iterator for IntoIter<T> {`
`1044`	`1049`	`fn size_hint(&self) -> (usize, Option<usize>) {`
`1045`	`1050`	`self.iter.size_hint()`
`1046`	`1051`	`}`
	`1052`	`+`
	`1053`	`+ #[inline]`
	`1054`	`+ fn last(mut self) -> Option<T> {`
	`1055`	`+ self.next_back()`
	`1056`	`+ }`
`1047`	`1057`	`}`
`1048`	`1058`	`#[stable(feature = "rust1", since = "1.0.0")]`
`1049`	`1059`	`impl<T> DoubleEndedIterator for IntoIter<T> {`
`@@ -1073,6 +1083,11 @@ impl<'a, T> Iterator for Range<'a, T> {`
`1073`	`1083`	`fn next(&mut self) -> Option<&'a T> {`
`1074`	`1084`	`self.iter.next().map(\|(k, _)\| k)`
`1075`	`1085`	`}`
	`1086`	`+`
	`1087`	`+ #[inline]`
	`1088`	`+ fn last(mut self) -> Option<&'a T> {`
	`1089`	`+ self.next_back()`
	`1090`	`+ }`
`1076`	`1091`	`}`
`1077`	`1092`
`1078`	`1093`	`#[stable(feature = "btree_range", since = "1.17.0")]`
Original file line number	Diff line number	Diff line change
`@@ -2367,6 +2367,10 @@ impl Iterator for Drain<'_> {`
`2367`	`2367`	`fn size_hint(&self) -> (usize, Option<usize>) {`
`2368`	`2368`	`self.iter.size_hint()`
`2369`	`2369`	`}`
	`2370`	`+ #[inline]`
	`2371`	`+ fn last(mut self) -> Option<char> {`
	`2372`	`+ self.next_back()`
	`2373`	`+ }`
`2370`	`2374`	`}`
`2371`	`2375`
`2372`	`2376`	`#[stable(feature = "drain", since = "1.6.0")]`
Original file line number	Diff line number	Diff line change
`@@ -2385,6 +2385,11 @@ impl<T> Iterator for IntoIter<T> {`
`2385`	`2385`	`fn count(self) -> usize {`
`2386`	`2386`	`self.len()`
`2387`	`2387`	`}`
	`2388`	`+`
	`2389`	`+ #[inline]`
	`2390`	`+ fn last(mut self) -> Option<T> {`
	`2391`	`+ self.next_back()`
	`2392`	`+ }`
`2388`	`2393`	`}`
`2389`	`2394`
`2390`	`2395`	`#[stable(feature = "rust1", since = "1.0.0")]`
`@@ -2504,6 +2509,11 @@ impl<T> Iterator for Drain<'_, T> {`
`2504`	`2509`	`fn size_hint(&self) -> (usize, Option<usize>) {`
`2505`	`2510`	`self.iter.size_hint()`
`2506`	`2511`	`}`
	`2512`	`+`
	`2513`	`+ #[inline]`
	`2514`	`+ fn last(mut self) -> Option<T> {`
	`2515`	`+ self.next_back()`
	`2516`	`+ }`
`2507`	`2517`	`}`
`2508`	`2518`
`2509`	`2519`	`#[stable(feature = "drain", since = "1.6.0")]`
`@@ -2573,6 +2583,10 @@ impl<I: Iterator> Iterator for Splice<'_, I> {`
`2573`	`2583`	`fn size_hint(&self) -> (usize, Option<usize>) {`
`2574`	`2584`	`self.drain.size_hint()`
`2575`	`2585`	`}`
	`2586`	`+`
	`2587`	`+ fn last(mut self) -> Option<Self::Item> {`
	`2588`	`+ self.next_back()`
	`2589`	`+ }`
`2576`	`2590`	`}`
`2577`	`2591`
`2578`	`2592`	`#[stable(feature = "vec_splice", since = "1.21.0")]`
Original file line number	Diff line number	Diff line change
`@@ -117,6 +117,8 @@ impl Iterator for EscapeDefault {`
`117`	`117`	`type Item = u8;`
`118`	`118`	`fn next(&mut self) -> Option<u8> { self.range.next().map(\|i\| self.data[i]) }`
`119`	`119`	`fn size_hint(&self) -> (usize, Option<usize>) { self.range.size_hint() }`
	`120`	`+ #[inline]`
	`121`	`+ fn last(mut self) -> Option<u8> { self.next_back() }`
`120`	`122`	`}`
`121`	`123`	`#[stable(feature = "rust1", since = "1.0.0")]`
`122`	`124`	`impl DoubleEndedIterator for EscapeDefault {`
Original file line number	Diff line number	Diff line change
`@@ -73,6 +73,11 @@ impl<I> Iterator for Rev<I> where I: DoubleEndedIterator {`
`73`	`73`	`{`
`74`	`74`	`self.iter.position(predicate)`
`75`	`75`	`}`
	`76`	`+`
	`77`	`+ #[inline]`
	`78`	`+ fn last(mut self) -> Option<Self::Item> {`
	`79`	`+ self.next_back()`
	`80`	`+ }`
`76`	`81`	`}`
`77`	`82`
`78`	`83`	`#[stable(feature = "rust1", since = "1.0.0")]`
Original file line number	Diff line number	Diff line change
`@@ -3539,6 +3539,11 @@ impl<'a, T, P> Iterator for Split<'a, T, P> where P: FnMut(&T) -> bool {`
`3539`	`3539`	`(1, Some(self.v.len() + 1))`
`3540`	`3540`	`}`
`3541`	`3541`	`}`
	`3542`	`+`
	`3543`	`+ #[inline]`
	`3544`	`+ fn last(mut self) -> Option<Self::Item> {`
	`3545`	`+ self.next_back()`
	`3546`	`+ }`
`3542`	`3547`	`}`
`3543`	`3548`
`3544`	`3549`	`#[stable(feature = "rust1", since = "1.0.0")]`
`@@ -3637,6 +3642,11 @@ impl<'a, T, P> Iterator for SplitMut<'a, T, P> where P: FnMut(&T) -> bool {`
`3637`	`3642`	`(1, Some(self.v.len() + 1))`
`3638`	`3643`	`}`
`3639`	`3644`	`}`
	`3645`	`+`
	`3646`	`+ #[inline]`
	`3647`	`+ fn last(mut self) -> Option<Self::Item> {`
	`3648`	`+ self.next_back()`
	`3649`	`+ }`
`3640`	`3650`	`}`
`3641`	`3651`
`3642`	`3652`	`#[stable(feature = "rust1", since = "1.0.0")]`
`@@ -3702,6 +3712,11 @@ impl<'a, T, P> Iterator for RSplit<'a, T, P> where P: FnMut(&T) -> bool {`
`3702`	`3712`	`fn size_hint(&self) -> (usize, Option<usize>) {`
`3703`	`3713`	`self.inner.size_hint()`
`3704`	`3714`	`}`
	`3715`	`+`
	`3716`	`+ #[inline]`
	`3717`	`+ fn last(mut self) -> Option<Self::Item> {`
	`3718`	`+ self.next_back()`
	`3719`	`+ }`
`3705`	`3720`	`}`
`3706`	`3721`
`3707`	`3722`	`#[stable(feature = "slice_rsplit", since = "1.27.0")]`
`@@ -3766,6 +3781,11 @@ impl<'a, T, P> Iterator for RSplitMut<'a, T, P> where P: FnMut(&T) -> bool {`
`3766`	`3781`	`fn size_hint(&self) -> (usize, Option<usize>) {`
`3767`	`3782`	`self.inner.size_hint()`
`3768`	`3783`	`}`
	`3784`	`+`
	`3785`	`+ #[inline]`
	`3786`	`+ fn last(mut self) -> Option<Self::Item> {`
	`3787`	`+ self.next_back()`
	`3788`	`+ }`
`3769`	`3789`	`}`
`3770`	`3790`
`3771`	`3791`	`#[stable(feature = "slice_rsplit", since = "1.27.0")]`
Original file line number	Diff line number	Diff line change
`@@ -1331,6 +1331,11 @@ impl<'a> Iterator for Lines<'a> {`
`1331`	`1331`	`fn size_hint(&self) -> (usize, Option<usize>) {`
`1332`	`1332`	`self.0.size_hint()`
`1333`	`1333`	`}`
	`1334`	`+`
	`1335`	`+ #[inline]`
	`1336`	`+ fn last(mut self) -> Option<Self::Item> {`
	`1337`	`+ self.next_back()`
	`1338`	`+ }`
`1334`	`1339`	`}`
`1335`	`1340`
`1336`	`1341`	`#[stable(feature = "rust1", since = "1.0.0")]`
`@@ -1377,6 +1382,11 @@ impl<'a> Iterator for LinesAny<'a> {`
`1377`	`1382`	`fn size_hint(&self) -> (usize, Option<usize>) {`
`1378`	`1383`	`self.0.size_hint()`
`1379`	`1384`	`}`
	`1385`	`+`
	`1386`	`+ #[inline]`
	`1387`	`+ fn last(mut self) -> Option<Self::Item> {`
	`1388`	`+ self.next_back()`
	`1389`	`+ }`
`1380`	`1390`	`}`
`1381`	`1391`
`1382`	`1392`	`#[stable(feature = "rust1", since = "1.0.0")]`
`@@ -4215,6 +4225,11 @@ impl<'a> Iterator for SplitWhitespace<'a> {`
`4215`	`4225`	`fn size_hint(&self) -> (usize, Option<usize>) {`
`4216`	`4226`	`self.inner.size_hint()`
`4217`	`4227`	`}`
	`4228`	`+`
	`4229`	`+ #[inline]`
	`4230`	`+ fn last(mut self) -> Option<Self::Item> {`
	`4231`	`+ self.next_back()`
	`4232`	`+ }`
`4218`	`4233`	`}`
`4219`	`4234`
`4220`	`4235`	`#[stable(feature = "split_whitespace", since = "1.1.0")]`
`@@ -4241,6 +4256,11 @@ impl<'a> Iterator for SplitAsciiWhitespace<'a> {`
`4241`	`4256`	`fn size_hint(&self) -> (usize, Option<usize>) {`
`4242`	`4257`	`self.inner.size_hint()`
`4243`	`4258`	`}`
	`4259`	`+`
	`4260`	`+ #[inline]`
	`4261`	`+ fn last(mut self) -> Option<Self::Item> {`
	`4262`	`+ self.next_back()`
	`4263`	`+ }`
`4244`	`4264`	`}`
`4245`	`4265`
`4246`	`4266`	`#[stable(feature = "split_ascii_whitespace", since = "1.34.0")]`
Original file line number	Diff line number	Diff line change
`@@ -740,6 +740,10 @@ impl Iterator for Args {`
`740`	`740`	`self.inner.next().map(\|s\| s.into_string().unwrap())`
`741`	`741`	`}`
`742`	`742`	`fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }`
	`743`	`+ #[inline]`
	`744`	`+ fn last(mut self) -> Option<String> {`
	`745`	`+ self.next_back()`
	`746`	`+ }`
`743`	`747`	`}`
`744`	`748`
`745`	`749`	`#[stable(feature = "env", since = "1.0.0")]`
`@@ -775,6 +779,8 @@ impl Iterator for ArgsOs {`
`775`	`779`	`type Item = OsString;`
`776`	`780`	`fn next(&mut self) -> Option<OsString> { self.inner.next() }`
`777`	`781`	`fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }`
	`782`	`+ #[inline]`
	`783`	`+ fn last(mut self) -> Option<OsString> { self.next_back() }`
`778`	`784`	`}`
`779`	`785`
`780`	`786`	`#[stable(feature = "env", since = "1.0.0")]`