Rollup merge of #73627 - ssomers:btree_iter_min_max, r=Mark-Simulacrum
Shortcuts for min/max on double-ended BTreeMap/BTreeSet iterators Closes #59947: a performance tweak that might benefit some. Optimizes `min` and `max ` on all btree double-ended iterators that do not drop, i.e. the iterators created by: - `BTreeMap::iter` - `BTreeMap::iter_mut` - `BTreeMap::keys` and `BTreeSet::iter` - `BTreeMap::range` and `BTreeSet::range` - `BTreeMap::range_mut` Also in these (currently) single-ended iterators, but obviously for `min` only: - `BTreeSet::difference` - `BTreeSet::intersection` - `BTreeSet::symmetric_difference` - `BTreeSet::union` Did not do this in iterators created by `into_iter` to preserve drop order, as outlined in #62316. Did not do this in iterators created by `drain_filter`, possibly to preserve drop order, possibly to preserve predicate invocation, mostly to not have to think about it too hard (I guess maybe it wouldn't be a change for `min`, which is the only shortcut possible in this single-ended iterator).
This commit is contained in:
commit
dfbba65786
4 changed files with 141 additions and 0 deletions
|
@ -1396,6 +1396,14 @@ impl<'a, K: 'a, V: 'a> Iterator for Iter<'a, K, V> {
|
|||
fn last(mut self) -> Option<(&'a K, &'a V)> {
|
||||
self.next_back()
|
||||
}
|
||||
|
||||
fn min(mut self) -> Option<(&'a K, &'a V)> {
|
||||
self.next()
|
||||
}
|
||||
|
||||
fn max(mut self) -> Option<(&'a K, &'a V)> {
|
||||
self.next_back()
|
||||
}
|
||||
}
|
||||
|
||||
#[stable(feature = "fused", since = "1.26.0")]
|
||||
|
@ -1458,6 +1466,14 @@ impl<'a, K: 'a, V: 'a> Iterator for IterMut<'a, K, V> {
|
|||
fn last(mut self) -> Option<(&'a K, &'a mut V)> {
|
||||
self.next_back()
|
||||
}
|
||||
|
||||
fn min(mut self) -> Option<(&'a K, &'a mut V)> {
|
||||
self.next()
|
||||
}
|
||||
|
||||
fn max(mut self) -> Option<(&'a K, &'a mut V)> {
|
||||
self.next_back()
|
||||
}
|
||||
}
|
||||
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
|
@ -1595,6 +1611,14 @@ impl<'a, K, V> Iterator for Keys<'a, K, V> {
|
|||
fn last(mut self) -> Option<&'a K> {
|
||||
self.next_back()
|
||||
}
|
||||
|
||||
fn min(mut self) -> Option<&'a K> {
|
||||
self.next()
|
||||
}
|
||||
|
||||
fn max(mut self) -> Option<&'a K> {
|
||||
self.next_back()
|
||||
}
|
||||
}
|
||||
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
|
@ -1768,6 +1792,14 @@ impl<'a, K, V> Iterator for Range<'a, K, V> {
|
|||
fn last(mut self) -> Option<(&'a K, &'a V)> {
|
||||
self.next_back()
|
||||
}
|
||||
|
||||
fn min(mut self) -> Option<(&'a K, &'a V)> {
|
||||
self.next()
|
||||
}
|
||||
|
||||
fn max(mut self) -> Option<(&'a K, &'a V)> {
|
||||
self.next_back()
|
||||
}
|
||||
}
|
||||
|
||||
#[stable(feature = "map_values_mut", since = "1.10.0")]
|
||||
|
@ -1853,6 +1885,14 @@ impl<'a, K, V> Iterator for RangeMut<'a, K, V> {
|
|||
fn last(mut self) -> Option<(&'a K, &'a mut V)> {
|
||||
self.next_back()
|
||||
}
|
||||
|
||||
fn min(mut self) -> Option<(&'a K, &'a mut V)> {
|
||||
self.next()
|
||||
}
|
||||
|
||||
fn max(mut self) -> Option<(&'a K, &'a mut V)> {
|
||||
self.next_back()
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, K, V> RangeMut<'a, K, V> {
|
||||
|
|
|
@ -1291,12 +1291,22 @@ impl<'a, T> Iterator for Iter<'a, T> {
|
|||
fn next(&mut self) -> Option<&'a T> {
|
||||
self.iter.next()
|
||||
}
|
||||
|
||||
fn size_hint(&self) -> (usize, Option<usize>) {
|
||||
self.iter.size_hint()
|
||||
}
|
||||
|
||||
fn last(mut self) -> Option<&'a T> {
|
||||
self.next_back()
|
||||
}
|
||||
|
||||
fn min(mut self) -> Option<&'a T> {
|
||||
self.next()
|
||||
}
|
||||
|
||||
fn max(mut self) -> Option<&'a T> {
|
||||
self.next_back()
|
||||
}
|
||||
}
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
impl<'a, T> DoubleEndedIterator for Iter<'a, T> {
|
||||
|
@ -1321,6 +1331,7 @@ impl<T> Iterator for IntoIter<T> {
|
|||
fn next(&mut self) -> Option<T> {
|
||||
self.iter.next().map(|(k, _)| k)
|
||||
}
|
||||
|
||||
fn size_hint(&self) -> (usize, Option<usize>) {
|
||||
self.iter.size_hint()
|
||||
}
|
||||
|
@ -1359,6 +1370,14 @@ impl<'a, T> Iterator for Range<'a, T> {
|
|||
fn last(mut self) -> Option<&'a T> {
|
||||
self.next_back()
|
||||
}
|
||||
|
||||
fn min(mut self) -> Option<&'a T> {
|
||||
self.next()
|
||||
}
|
||||
|
||||
fn max(mut self) -> Option<&'a T> {
|
||||
self.next_back()
|
||||
}
|
||||
}
|
||||
|
||||
#[stable(feature = "btree_range", since = "1.17.0")]
|
||||
|
@ -1429,6 +1448,10 @@ impl<'a, T: Ord> Iterator for Difference<'a, T> {
|
|||
};
|
||||
(self_len.saturating_sub(other_len), Some(self_len))
|
||||
}
|
||||
|
||||
fn min(mut self) -> Option<&'a T> {
|
||||
self.next()
|
||||
}
|
||||
}
|
||||
|
||||
#[stable(feature = "fused", since = "1.26.0")]
|
||||
|
@ -1460,6 +1483,10 @@ impl<'a, T: Ord> Iterator for SymmetricDifference<'a, T> {
|
|||
// the number of elements to less than half the range of usize.
|
||||
(0, Some(a_len + b_len))
|
||||
}
|
||||
|
||||
fn min(mut self) -> Option<&'a T> {
|
||||
self.next()
|
||||
}
|
||||
}
|
||||
|
||||
#[stable(feature = "fused", since = "1.26.0")]
|
||||
|
@ -1516,6 +1543,10 @@ impl<'a, T: Ord> Iterator for Intersection<'a, T> {
|
|||
IntersectionInner::Answer(Some(_)) => (1, Some(1)),
|
||||
}
|
||||
}
|
||||
|
||||
fn min(mut self) -> Option<&'a T> {
|
||||
self.next()
|
||||
}
|
||||
}
|
||||
|
||||
#[stable(feature = "fused", since = "1.26.0")]
|
||||
|
@ -1541,6 +1572,10 @@ impl<'a, T: Ord> Iterator for Union<'a, T> {
|
|||
// No checked_add - see SymmetricDifference::size_hint.
|
||||
(max(a_len, b_len), Some(a_len + b_len))
|
||||
}
|
||||
|
||||
fn min(mut self) -> Option<&'a T> {
|
||||
self.next()
|
||||
}
|
||||
}
|
||||
|
||||
#[stable(feature = "fused", since = "1.26.0")]
|
||||
|
|
|
@ -309,6 +309,41 @@ fn test_iter_mixed() {
|
|||
test(size, map.into_iter());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_iter_min_max() {
|
||||
let mut a = BTreeMap::new();
|
||||
assert_eq!(a.iter().min(), None);
|
||||
assert_eq!(a.iter().max(), None);
|
||||
assert_eq!(a.iter_mut().min(), None);
|
||||
assert_eq!(a.iter_mut().max(), None);
|
||||
assert_eq!(a.range(..).min(), None);
|
||||
assert_eq!(a.range(..).max(), None);
|
||||
assert_eq!(a.range_mut(..).min(), None);
|
||||
assert_eq!(a.range_mut(..).max(), None);
|
||||
assert_eq!(a.keys().min(), None);
|
||||
assert_eq!(a.keys().max(), None);
|
||||
assert_eq!(a.values().min(), None);
|
||||
assert_eq!(a.values().max(), None);
|
||||
assert_eq!(a.values_mut().min(), None);
|
||||
assert_eq!(a.values_mut().max(), None);
|
||||
a.insert(1, 42);
|
||||
a.insert(2, 24);
|
||||
assert_eq!(a.iter().min(), Some((&1, &42)));
|
||||
assert_eq!(a.iter().max(), Some((&2, &24)));
|
||||
assert_eq!(a.iter_mut().min(), Some((&1, &mut 42)));
|
||||
assert_eq!(a.iter_mut().max(), Some((&2, &mut 24)));
|
||||
assert_eq!(a.range(..).min(), Some((&1, &42)));
|
||||
assert_eq!(a.range(..).max(), Some((&2, &24)));
|
||||
assert_eq!(a.range_mut(..).min(), Some((&1, &mut 42)));
|
||||
assert_eq!(a.range_mut(..).max(), Some((&2, &mut 24)));
|
||||
assert_eq!(a.keys().min(), Some(&1));
|
||||
assert_eq!(a.keys().max(), Some(&2));
|
||||
assert_eq!(a.values().min(), Some(&24));
|
||||
assert_eq!(a.values().max(), Some(&42));
|
||||
assert_eq!(a.values_mut().min(), Some(&mut 24));
|
||||
assert_eq!(a.values_mut().max(), Some(&mut 42));
|
||||
}
|
||||
|
||||
fn range_keys(map: &BTreeMap<i32, i32>, range: impl RangeBounds<i32>) -> Vec<i32> {
|
||||
map.range(range)
|
||||
.map(|(&k, &v)| {
|
||||
|
|
|
@ -33,6 +33,37 @@ fn test_hash() {
|
|||
assert_eq!(hash(&x), hash(&y));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_iter_min_max() {
|
||||
let mut a = BTreeSet::new();
|
||||
assert_eq!(a.iter().min(), None);
|
||||
assert_eq!(a.iter().max(), None);
|
||||
assert_eq!(a.range(..).min(), None);
|
||||
assert_eq!(a.range(..).max(), None);
|
||||
assert_eq!(a.difference(&BTreeSet::new()).min(), None);
|
||||
assert_eq!(a.difference(&BTreeSet::new()).max(), None);
|
||||
assert_eq!(a.intersection(&a).min(), None);
|
||||
assert_eq!(a.intersection(&a).max(), None);
|
||||
assert_eq!(a.symmetric_difference(&BTreeSet::new()).min(), None);
|
||||
assert_eq!(a.symmetric_difference(&BTreeSet::new()).max(), None);
|
||||
assert_eq!(a.union(&a).min(), None);
|
||||
assert_eq!(a.union(&a).max(), None);
|
||||
a.insert(1);
|
||||
a.insert(2);
|
||||
assert_eq!(a.iter().min(), Some(&1));
|
||||
assert_eq!(a.iter().max(), Some(&2));
|
||||
assert_eq!(a.range(..).min(), Some(&1));
|
||||
assert_eq!(a.range(..).max(), Some(&2));
|
||||
assert_eq!(a.difference(&BTreeSet::new()).min(), Some(&1));
|
||||
assert_eq!(a.difference(&BTreeSet::new()).max(), Some(&2));
|
||||
assert_eq!(a.intersection(&a).min(), Some(&1));
|
||||
assert_eq!(a.intersection(&a).max(), Some(&2));
|
||||
assert_eq!(a.symmetric_difference(&BTreeSet::new()).min(), Some(&1));
|
||||
assert_eq!(a.symmetric_difference(&BTreeSet::new()).max(), Some(&2));
|
||||
assert_eq!(a.union(&a).min(), Some(&1));
|
||||
assert_eq!(a.union(&a).max(), Some(&2));
|
||||
}
|
||||
|
||||
fn check<F>(a: &[i32], b: &[i32], expected: &[i32], f: F)
|
||||
where
|
||||
F: FnOnce(&BTreeSet<i32>, &BTreeSet<i32>, &mut dyn FnMut(&i32) -> bool) -> bool,
|
||||
|
|
Loading…
Reference in a new issue