Rollup merge of #147808 - hkBst:btree-3, r=joboet

btree: cleanup difference, intersection, is_subset

Author: jhpratt

library/alloc/src/collections/btree/set.rs

@@ -427,39 +427,35 @@ impl<T, A: Allocator + Clone> BTreeSet<T, A> {
 where
 T:Ord,
 {
-let(self_min, self_max) =
-iflet(Some(self_min),Some(self_max)) = (self.first(),self.last()){
-(self_min, self_max)
-}else{
-returnDifference{inner:DifferenceInner::Iterate(self.iter())};
-};
-let(other_min, other_max) =
-iflet(Some(other_min),Some(other_max)) = (other.first(), other.last()){
-(other_min, other_max)
-}else{
-returnDifference{inner:DifferenceInner::Iterate(self.iter())};
-};
-Difference{
-inner:match(self_min.cmp(other_max), self_max.cmp(other_min)){
-(Greater, _) | (_,Less) => DifferenceInner::Iterate(self.iter()),
-(Equal, _) => {
-letmut self_iter = self.iter();
- self_iter.next();
-DifferenceInner::Iterate(self_iter)
-}
-(_,Equal) => {
-letmut self_iter = self.iter();
- self_iter.next_back();
-DifferenceInner::Iterate(self_iter)
-}
- _ ifself.len() <= other.len() / ITER_PERFORMANCE_TIPPING_SIZE_DIFF => {
-DifferenceInner::Search{self_iter:self.iter(),other_set: other }
-}
- _ => DifferenceInner::Stitch{
-self_iter:self.iter(),
-other_iter: other.iter().peekable(),
+ifletSome(self_min) = self.first()
+ && letSome(self_max) = self.last()
+ && letSome(other_min) = other.first()
+ && letSome(other_max) = other.last()
+{
+Difference{
+inner:match(self_min.cmp(other_max), self_max.cmp(other_min)){
+(Greater, _) | (_,Less) => DifferenceInner::Iterate(self.iter()),
+(Equal, _) => {
+letmut self_iter = self.iter();
+ self_iter.next();
+DifferenceInner::Iterate(self_iter)
+}
+(_,Equal) => {
+letmut self_iter = self.iter();
+ self_iter.next_back();
+DifferenceInner::Iterate(self_iter)
+}
+ _ ifself.len() <= other.len() / ITER_PERFORMANCE_TIPPING_SIZE_DIFF => {
+DifferenceInner::Search{self_iter:self.iter(),other_set: other }
+}
+ _ => DifferenceInner::Stitch{
+self_iter:self.iter(),
+other_iter: other.iter().peekable(),
+},
 },
-},
+}
+}else{
+Difference{inner:DifferenceInner::Iterate(self.iter())}
 }
 }
 
@@ -519,31 +515,27 @@ impl<T, A: Allocator + Clone> BTreeSet<T, A> {
 where
 T:Ord,
 {
-let(self_min, self_max) =
-iflet(Some(self_min),Some(self_max)) = (self.first(),self.last()){
-(self_min, self_max)
-}else{
-returnIntersection{inner:IntersectionInner::Answer(None)};
-};
-let(other_min, other_max) =
-iflet(Some(other_min),Some(other_max)) = (other.first(), other.last()){
-(other_min, other_max)
-}else{
-returnIntersection{inner:IntersectionInner::Answer(None)};
-};
-Intersection{
-inner:match(self_min.cmp(other_max), self_max.cmp(other_min)){
-(Greater, _) | (_,Less) => IntersectionInner::Answer(None),
-(Equal, _) => IntersectionInner::Answer(Some(self_min)),
-(_,Equal) => IntersectionInner::Answer(Some(self_max)),
- _ ifself.len() <= other.len() / ITER_PERFORMANCE_TIPPING_SIZE_DIFF => {
-IntersectionInner::Search{small_iter:self.iter(),large_set: other }
-}
- _ if other.len() <= self.len() / ITER_PERFORMANCE_TIPPING_SIZE_DIFF => {
-IntersectionInner::Search{small_iter: other.iter(),large_set:self}
-}
- _ => IntersectionInner::Stitch{a:self.iter(),b: other.iter()},
-},
+ifletSome(self_min) = self.first()
+ && letSome(self_max) = self.last()
+ && letSome(other_min) = other.first()
+ && letSome(other_max) = other.last()
+{
+Intersection{
+inner:match(self_min.cmp(other_max), self_max.cmp(other_min)){
+(Greater, _) | (_,Less) => IntersectionInner::Answer(None),
+(Equal, _) => IntersectionInner::Answer(Some(self_min)),
+(_,Equal) => IntersectionInner::Answer(Some(self_max)),
+ _ ifself.len() <= other.len() / ITER_PERFORMANCE_TIPPING_SIZE_DIFF => {
+IntersectionInner::Search{small_iter:self.iter(),large_set: other }
+}
+ _ if other.len() <= self.len() / ITER_PERFORMANCE_TIPPING_SIZE_DIFF => {
+IntersectionInner::Search{small_iter: other.iter(),large_set:self}
+}
+ _ => IntersectionInner::Stitch{a:self.iter(),b: other.iter()},
+},
+}
+}else{
+Intersection{inner:IntersectionInner::Answer(None)}
 }
 }
 
@@ -694,55 +686,56 @@ impl<T, A: Allocator + Clone> BTreeSet<T, A> {
 // Same result as self.difference(other).next().is_none()
 // but the code below is faster (hugely in some cases).
 ifself.len() > other.len(){
-returnfalse;
+returnfalse;// self has more elements than other
 }
-let(self_min, self_max) =
-iflet(Some(self_min),Some(self_max)) = (self.first(),self.last()){
-(self_min, self_max)
-}else{
-returntrue;// self is empty
-};
-let(other_min, other_max) =
-iflet(Some(other_min),Some(other_max)) = (other.first(), other.last()){
-(other_min, other_max)
-}else{
-returnfalse;// other is empty
-};
+let(Some(self_min),Some(self_max)) = (self.first(),self.last())else{
+returntrue;// self is empty
+};
+let(Some(other_min),Some(other_max)) = (other.first(), other.last())else{
+returnfalse;// other is empty
+};
 letmut self_iter = self.iter();
 match self_min.cmp(other_min){
-Less => returnfalse,
+Less => returnfalse,// other does not contain self_min
 Equal => {
- self_iter.next();
+ self_iter.next();// self_min is contained in other, so remove it from consideration
+// other_min is now not in self_iter (used below)
 }
-Greater => (),
-}
+Greater => {}// other_min is not in self_iter (used below)
+};
+
 match self_max.cmp(other_max){
-Greater => returnfalse,
+Greater => returnfalse,// other does not contain self_max
 Equal => {
- self_iter.next_back();
+ self_iter.next_back();// self_max is contained in other, so remove it from consideration
+// other_max is now not in self_iter (used below)
 }
-Less => (),
-}
+Less => {}// other_max is not in self_iter (used below)
+};
 if self_iter.len() <= other.len() / ITER_PERFORMANCE_TIPPING_SIZE_DIFF{
-for next in self_iter {
-if !other.contains(next){
-returnfalse;
-}
-}
+ self_iter.all(|e| other.contains(e))
 }else{
 letmut other_iter = other.iter();
- other_iter.next();
- other_iter.next_back();
-letmut self_next = self_iter.next();
-whileletSome(self1) = self_next {
-match other_iter.next().map_or(Less, |other1| self1.cmp(other1)){
-Less => returnfalse,
-Equal => self_next = self_iter.next(),
-Greater => (),
-}
+{
+// remove other_min and other_max as they are not in self_iter (see above)
+ other_iter.next();
+ other_iter.next_back();
 }
+// custom `self_iter.all(|e| other.contains(e))`
+ self_iter.all(|self1| {
+whileletSome(other1) = other_iter.next(){
+match other1.cmp(self1){
+// happens up to `ITER_PERFORMANCE_TIPPING_SIZE_DIFF * self.len() - 1` times
+Less => continue,// skip over elements that are smaller
+// happens `self.len()` times
+Equal => returntrue,// self1 is in other
+// happens only once
+Greater => returnfalse,// self1 is not in other
+}
+}
+false
+})
 }
-true
 }
 
 /// Returns `true` if the set is a superset of another,

library/alloctests/Cargo.toml

@@ -6,7 +6,7 @@ repository = "https://github.com/rust-lang/rust.git"
 description = "Tests for the Rust Allocation Library"
 autotests = false
 autobenches = false
-edition = "2021"
+edition = "2024"
 
 [lib]
 path = "lib.rs"