Rollup merge of rust-lang#60130 - khuey:efficient_last, r=sfackler

Centril · web-flow · commit bab03cecfead · 2019-05-14T22:00:09.000+02:00
Add implementations of last in terms of next_back on a bunch of DoubleEndedIterators

Provided a `DoubleEndedIterator` has finite length, `Iterator::last` is equivalent to `DoubleEndedIterator::next_back`. But searching forwards through the iterator when it's unnecessary is obviously not good for performance. I ran into this on one of the collection iterators.

I tried adding appropriate overloads for a bunch of the iterator adapters like filter, map, etc, but I ran into a lot of type inference failures after doing so.

The other interesting case is what to do with `Repeat`. Do we consider it part of the contract that `Iterator::last` will loop forever on it? The docs do say that the iterator will be evaluated until it returns None. This is also relevant for the adapters, it's trivially easy to observe whether a `Map` adapter invoked its closure a zillion times or just once for the last element.
diff --git a/src/liballoc/collections/binary_heap.rs b/src/liballoc/collections/binary_heap.rs
@@ -992,6 +992,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")]
@@ -1047,6 +1052,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")]
@@ -1093,6 +1103,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
@@ -2377,6 +2377,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
@@ -2395,6 +2395,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")]
@@ -2514,6 +2519,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")]
@@ -2583,6 +2593,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
@@ -3541,6 +3541,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")]
@@ -3639,6 +3644,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")]
@@ -3704,6 +3714,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")]
@@ -3768,6 +3783,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
@@ -1333,6 +1333,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")]
@@ -1379,6 +1384,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")]
@@ -4217,6 +4227,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")]
@@ -4243,6 +4258,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
@@ -746,6 +746,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")]
@@ -781,6 +785,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
@@ -888,6 +888,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")]
@@ -951,6 +956,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
`@@ -992,6 +992,11 @@ impl<'a, T> Iterator for Iter<'a, T> {`
`992`	`992`	`fn size_hint(&self) -> (usize, Option<usize>) {`
`993`	`993`	`self.iter.size_hint()`
`994`	`994`	`}`
	`995`	`+`
	`996`	`+ #[inline]`
	`997`	`+ fn last(mut self) -> Option<&'a T> {`
	`998`	`+ self.next_back()`
	`999`	`+ }`
`995`	`1000`	`}`
`996`	`1001`
`997`	`1002`	`#[stable(feature = "rust1", since = "1.0.0")]`
`@@ -1047,6 +1052,11 @@ impl<T> Iterator for IntoIter<T> {`
`1047`	`1052`	`fn size_hint(&self) -> (usize, Option<usize>) {`
`1048`	`1053`	`self.iter.size_hint()`
`1049`	`1054`	`}`
	`1055`	`+`
	`1056`	`+ #[inline]`
	`1057`	`+ fn last(mut self) -> Option<T> {`
	`1058`	`+ self.next_back()`
	`1059`	`+ }`
`1050`	`1060`	`}`
`1051`	`1061`
`1052`	`1062`	`#[stable(feature = "rust1", since = "1.0.0")]`
`@@ -1093,6 +1103,11 @@ impl<T> Iterator for Drain<'_, T> {`
`1093`	`1103`	`fn size_hint(&self) -> (usize, Option<usize>) {`
`1094`	`1104`	`self.iter.size_hint()`
`1095`	`1105`	`}`
	`1106`	`+`
	`1107`	`+ #[inline]`
	`1108`	`+ fn last(mut self) -> Option<T> {`
	`1109`	`+ self.next_back()`
	`1110`	`+ }`
`1096`	`1111`	`}`
`1097`	`1112`
`1098`	`1113`	`#[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
`@@ -2377,6 +2377,10 @@ impl Iterator for Drain<'_> {`
`2377`	`2377`	`fn size_hint(&self) -> (usize, Option<usize>) {`
`2378`	`2378`	`self.iter.size_hint()`
`2379`	`2379`	`}`
	`2380`	`+ #[inline]`
	`2381`	`+ fn last(mut self) -> Option<char> {`
	`2382`	`+ self.next_back()`
	`2383`	`+ }`
`2380`	`2384`	`}`
`2381`	`2385`
`2382`	`2386`	`#[stable(feature = "drain", since = "1.6.0")]`
Original file line number	Diff line number	Diff line change
`@@ -2395,6 +2395,11 @@ impl<T> Iterator for IntoIter<T> {`
`2395`	`2395`	`fn count(self) -> usize {`
`2396`	`2396`	`self.len()`
`2397`	`2397`	`}`
	`2398`	`+`
	`2399`	`+ #[inline]`
	`2400`	`+ fn last(mut self) -> Option<T> {`
	`2401`	`+ self.next_back()`
	`2402`	`+ }`
`2398`	`2403`	`}`
`2399`	`2404`
`2400`	`2405`	`#[stable(feature = "rust1", since = "1.0.0")]`
`@@ -2514,6 +2519,11 @@ impl<T> Iterator for Drain<'_, T> {`
`2514`	`2519`	`fn size_hint(&self) -> (usize, Option<usize>) {`
`2515`	`2520`	`self.iter.size_hint()`
`2516`	`2521`	`}`
	`2522`	`+`
	`2523`	`+ #[inline]`
	`2524`	`+ fn last(mut self) -> Option<T> {`
	`2525`	`+ self.next_back()`
	`2526`	`+ }`
`2517`	`2527`	`}`
`2518`	`2528`
`2519`	`2529`	`#[stable(feature = "drain", since = "1.6.0")]`
`@@ -2583,6 +2593,10 @@ impl<I: Iterator> Iterator for Splice<'_, I> {`
`2583`	`2593`	`fn size_hint(&self) -> (usize, Option<usize>) {`
`2584`	`2594`	`self.drain.size_hint()`
`2585`	`2595`	`}`
	`2596`	`+`
	`2597`	`+ fn last(mut self) -> Option<Self::Item> {`
	`2598`	`+ self.next_back()`
	`2599`	`+ }`
`2586`	`2600`	`}`
`2587`	`2601`
`2588`	`2602`	`#[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
`@@ -3541,6 +3541,11 @@ impl<'a, T, P> Iterator for Split<'a, T, P> where P: FnMut(&T) -> bool {`
`3541`	`3541`	`(1, Some(self.v.len() + 1))`
`3542`	`3542`	`}`
`3543`	`3543`	`}`
	`3544`	`+`
	`3545`	`+ #[inline]`
	`3546`	`+ fn last(mut self) -> Option<Self::Item> {`
	`3547`	`+ self.next_back()`
	`3548`	`+ }`
`3544`	`3549`	`}`
`3545`	`3550`
`3546`	`3551`	`#[stable(feature = "rust1", since = "1.0.0")]`
`@@ -3639,6 +3644,11 @@ impl<'a, T, P> Iterator for SplitMut<'a, T, P> where P: FnMut(&T) -> bool {`
`3639`	`3644`	`(1, Some(self.v.len() + 1))`
`3640`	`3645`	`}`
`3641`	`3646`	`}`
	`3647`	`+`
	`3648`	`+ #[inline]`
	`3649`	`+ fn last(mut self) -> Option<Self::Item> {`
	`3650`	`+ self.next_back()`
	`3651`	`+ }`
`3642`	`3652`	`}`
`3643`	`3653`
`3644`	`3654`	`#[stable(feature = "rust1", since = "1.0.0")]`
`@@ -3704,6 +3714,11 @@ impl<'a, T, P> Iterator for RSplit<'a, T, P> where P: FnMut(&T) -> bool {`
`3704`	`3714`	`fn size_hint(&self) -> (usize, Option<usize>) {`
`3705`	`3715`	`self.inner.size_hint()`
`3706`	`3716`	`}`
	`3717`	`+`
	`3718`	`+ #[inline]`
	`3719`	`+ fn last(mut self) -> Option<Self::Item> {`
	`3720`	`+ self.next_back()`
	`3721`	`+ }`
`3707`	`3722`	`}`
`3708`	`3723`
`3709`	`3724`	`#[stable(feature = "slice_rsplit", since = "1.27.0")]`
`@@ -3768,6 +3783,11 @@ impl<'a, T, P> Iterator for RSplitMut<'a, T, P> where P: FnMut(&T) -> bool {`
`3768`	`3783`	`fn size_hint(&self) -> (usize, Option<usize>) {`
`3769`	`3784`	`self.inner.size_hint()`
`3770`	`3785`	`}`
	`3786`	`+`
	`3787`	`+ #[inline]`
	`3788`	`+ fn last(mut self) -> Option<Self::Item> {`
	`3789`	`+ self.next_back()`
	`3790`	`+ }`
`3771`	`3791`	`}`
`3772`	`3792`
`3773`	`3793`	`#[stable(feature = "slice_rsplit", since = "1.27.0")]`
Original file line number	Diff line number	Diff line change
`@@ -1333,6 +1333,11 @@ impl<'a> Iterator for Lines<'a> {`
`1333`	`1333`	`fn size_hint(&self) -> (usize, Option<usize>) {`
`1334`	`1334`	`self.0.size_hint()`
`1335`	`1335`	`}`
	`1336`	`+`
	`1337`	`+ #[inline]`
	`1338`	`+ fn last(mut self) -> Option<Self::Item> {`
	`1339`	`+ self.next_back()`
	`1340`	`+ }`
`1336`	`1341`	`}`
`1337`	`1342`
`1338`	`1343`	`#[stable(feature = "rust1", since = "1.0.0")]`
`@@ -1379,6 +1384,11 @@ impl<'a> Iterator for LinesAny<'a> {`
`1379`	`1384`	`fn size_hint(&self) -> (usize, Option<usize>) {`
`1380`	`1385`	`self.0.size_hint()`
`1381`	`1386`	`}`
	`1387`	`+`
	`1388`	`+ #[inline]`
	`1389`	`+ fn last(mut self) -> Option<Self::Item> {`
	`1390`	`+ self.next_back()`
	`1391`	`+ }`
`1382`	`1392`	`}`
`1383`	`1393`
`1384`	`1394`	`#[stable(feature = "rust1", since = "1.0.0")]`
`@@ -4217,6 +4227,11 @@ impl<'a> Iterator for SplitWhitespace<'a> {`
`4217`	`4227`	`fn size_hint(&self) -> (usize, Option<usize>) {`
`4218`	`4228`	`self.inner.size_hint()`
`4219`	`4229`	`}`
	`4230`	`+`
	`4231`	`+ #[inline]`
	`4232`	`+ fn last(mut self) -> Option<Self::Item> {`
	`4233`	`+ self.next_back()`
	`4234`	`+ }`
`4220`	`4235`	`}`
`4221`	`4236`
`4222`	`4237`	`#[stable(feature = "split_whitespace", since = "1.1.0")]`
`@@ -4243,6 +4258,11 @@ impl<'a> Iterator for SplitAsciiWhitespace<'a> {`
`4243`	`4258`	`fn size_hint(&self) -> (usize, Option<usize>) {`
`4244`	`4259`	`self.inner.size_hint()`
`4245`	`4260`	`}`
	`4261`	`+`
	`4262`	`+ #[inline]`
	`4263`	`+ fn last(mut self) -> Option<Self::Item> {`
	`4264`	`+ self.next_back()`
	`4265`	`+ }`
`4246`	`4266`	`}`
`4247`	`4267`
`4248`	`4268`	`#[stable(feature = "split_ascii_whitespace", since = "1.34.0")]`
Original file line number	Diff line number	Diff line change
`@@ -746,6 +746,10 @@ impl Iterator for Args {`
`746`	`746`	`self.inner.next().map(\|s\| s.into_string().unwrap())`
`747`	`747`	`}`
`748`	`748`	`fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }`
	`749`	`+ #[inline]`
	`750`	`+ fn last(mut self) -> Option<String> {`
	`751`	`+ self.next_back()`
	`752`	`+ }`
`749`	`753`	`}`
`750`	`754`
`751`	`755`	`#[stable(feature = "env", since = "1.0.0")]`
`@@ -781,6 +785,8 @@ impl Iterator for ArgsOs {`
`781`	`785`	`type Item = OsString;`
`782`	`786`	`fn next(&mut self) -> Option<OsString> { self.inner.next() }`
`783`	`787`	`fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }`
	`788`	`+ #[inline]`
	`789`	`+ fn last(mut self) -> Option<OsString> { self.next_back() }`
`784`	`790`	`}`
`785`	`791`
`786`	`792`	`#[stable(feature = "env", since = "1.0.0")]`