BTree: add drain methods

library/alloc/benches/btree/map.rs

@@ -384,17 +384,33 @@ pub fn clone_slim_100_and_clear(b: &mut Bencher) {
 }
 
 #[bench]
-pub fn clone_slim_100_and_drain_all(b: &mut Bencher) {
+pub fn clone_slim_100_and_drain_range_all(b: &mut Bencher) {
+    let src = slim_map(100);
+    b.iter(|| src.clone().drain(..).count())
+}
+
+#[bench]
+pub fn clone_slim_100_and_drain_filter_all(b: &mut Bencher) {
     let src = slim_map(100);
     b.iter(|| src.clone().drain_filter(|_, _| true).count())
 }
 
 #[bench]
-pub fn clone_slim_100_and_drain_half(b: &mut Bencher) {
+pub fn clone_slim_100_and_drain_range_half(b: &mut Bencher) {
+    let src = slim_map(100);
+    b.iter(|| {
+        let mut map = src.clone();
+        assert_eq!(map.drain(25..75).count(), 100 / 2);
+        assert_eq!(map.len(), 100 / 2);
+    })
+}
+
+#[bench]
+pub fn clone_slim_100_and_drain_filter_half(b: &mut Bencher) {
     let src = slim_map(100);
     b.iter(|| {
         let mut map = src.clone();
-        assert_eq!(map.drain_filter(|i, _| i % 2 == 0).count(), 100 / 2);
+        assert_eq!(map.drain_filter(|i, _| (25..75).contains(i)).count(), 100 / 2);
         assert_eq!(map.len(), 100 / 2);
     })
 }
@@ -455,17 +471,33 @@ pub fn clone_slim_10k_and_clear(b: &mut Bencher) {
 }
 
 #[bench]
-pub fn clone_slim_10k_and_drain_all(b: &mut Bencher) {
+pub fn clone_slim_10k_and_drain_range_all(b: &mut Bencher) {
+    let src = slim_map(10_000);
+    b.iter(|| src.clone().drain(..).count())
+}
+
+#[bench]
+pub fn clone_slim_10k_and_drain_filter_all(b: &mut Bencher) {
     let src = slim_map(10_000);
     b.iter(|| src.clone().drain_filter(|_, _| true).count())
 }
 
 #[bench]
-pub fn clone_slim_10k_and_drain_half(b: &mut Bencher) {
+pub fn clone_slim_10k_and_drain_range_half(b: &mut Bencher) {
+    let src = slim_map(10_000);
+    b.iter(|| {
+        let mut map = src.clone();
+        assert_eq!(map.drain(2500..7500).count(), 10_000 / 2);
+        assert_eq!(map.len(), 10_000 / 2);
+    })
+}
+
+#[bench]
+pub fn clone_slim_10k_and_drain_filter_half(b: &mut Bencher) {
     let src = slim_map(10_000);
     b.iter(|| {
         let mut map = src.clone();
-        assert_eq!(map.drain_filter(|i, _| i % 2 == 0).count(), 10_000 / 2);
+        assert_eq!(map.drain_filter(|i, _| (2500..7500).contains(i)).count(), 10_000 / 2);
         assert_eq!(map.len(), 10_000 / 2);
     })
 }
@@ -526,17 +558,33 @@ pub fn clone_fat_val_100_and_clear(b: &mut Bencher) {
 }
 
 #[bench]
-pub fn clone_fat_val_100_and_drain_all(b: &mut Bencher) {
+pub fn clone_fat_val_100_and_drain_range_all(b: &mut Bencher) {
+    let src = fat_val_map(100);
+    b.iter(|| src.clone().drain(..).count())
+}
+
+#[bench]
+pub fn clone_fat_val_100_and_drain_filter_all(b: &mut Bencher) {
     let src = fat_val_map(100);
     b.iter(|| src.clone().drain_filter(|_, _| true).count())
 }
 
 #[bench]
-pub fn clone_fat_val_100_and_drain_half(b: &mut Bencher) {
+pub fn clone_fat_val_100_and_drain_range_half(b: &mut Bencher) {
+    let src = fat_val_map(100);
+    b.iter(|| {
+        let mut map = src.clone();
+        assert_eq!(map.drain(25..75).count(), 100 / 2);
+        assert_eq!(map.len(), 100 / 2);
+    })
+}
+
+#[bench]
+pub fn clone_fat_val_100_and_drain_filter_half(b: &mut Bencher) {
     let src = fat_val_map(100);
     b.iter(|| {
         let mut map = src.clone();
-        assert_eq!(map.drain_filter(|i, _| i % 2 == 0).count(), 100 / 2);
+        assert_eq!(map.drain_filter(|i, _| (25..75).contains(i)).count(), 100 / 2);
         assert_eq!(map.len(), 100 / 2);
     })
 }

library/alloc/benches/lib.rs

@@ -1,6 +1,7 @@
 // Disabling on android for the time being
 // See https://github.com/rust-lang/rust/issues/73535#event-3477699747
 #![cfg(not(target_os = "android"))]
+#![feature(btree_drain)]
 #![feature(btree_drain_filter)]
 #![feature(map_first_last)]
 #![feature(repr_simd)]