Skip to content

Commit 30f0ded

Browse files
LukasKalbertodtLukasKalbertodt
committed
Use the IntoIterator array impl in several places across library/*
I surely missed quite a few spots, but I think I got most of them. And it's not like changing this is particularly important.
1 parent 25efe72 commit 30f0ded

File tree

21 files changed

+101
-102
lines changed

21 files changed

+101
-102
lines changed

Diff for: ‎library/alloc/src/collections/btree/map/tests.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -1289,7 +1289,7 @@ fn test_borrow() {
12891289
fn test_entry() {
12901290
let xs = [(1, 10), (2, 20), (3, 30), (4, 40), (5, 50), (6, 60)];
12911291

1292-
let mut map: BTreeMap<_, _> = xs.iter().cloned().collect();
1292+
let mut map: BTreeMap<_, _> = xs.into_iter().collect();
12931293

12941294
// Existing key (insert)
12951295
match map.entry(1) {

Diff for: ‎library/alloc/src/collections/btree/set.rs

+9-9
Original file line numberDiff line numberDiff line change
@@ -473,7 +473,7 @@ impl<T> BTreeSet<T> {
473473
/// ```
474474
/// use std::collections::BTreeSet;
475475
///
476-
/// let set: BTreeSet<_> = [1, 2, 3].iter().cloned().collect();
476+
/// let set: BTreeSet<_> = [1, 2, 3].into_iter().collect();
477477
/// assert_eq!(set.contains(&1), true);
478478
/// assert_eq!(set.contains(&4), false);
479479
/// ```
@@ -497,7 +497,7 @@ impl<T> BTreeSet<T> {
497497
/// ```
498498
/// use std::collections::BTreeSet;
499499
///
500-
/// let set: BTreeSet<_> = [1, 2, 3].iter().cloned().collect();
500+
/// let set: BTreeSet<_> = [1, 2, 3].into_iter().collect();
501501
/// assert_eq!(set.get(&2), Some(&2));
502502
/// assert_eq!(set.get(&4), None);
503503
/// ```
@@ -518,7 +518,7 @@ impl<T> BTreeSet<T> {
518518
/// ```
519519
/// use std::collections::BTreeSet;
520520
///
521-
/// let a: BTreeSet<_> = [1, 2, 3].iter().cloned().collect();
521+
/// let a: BTreeSet<_> = [1, 2, 3].into_iter().collect();
522522
/// let mut b = BTreeSet::new();
523523
///
524524
/// assert_eq!(a.is_disjoint(&b), true);
@@ -543,7 +543,7 @@ impl<T> BTreeSet<T> {
543543
/// ```
544544
/// use std::collections::BTreeSet;
545545
///
546-
/// let sup: BTreeSet<_> = [1, 2, 3].iter().cloned().collect();
546+
/// let sup: BTreeSet<_> = [1, 2, 3].into_iter().collect();
547547
/// let mut set = BTreeSet::new();
548548
///
549549
/// assert_eq!(set.is_subset(&sup), true);
@@ -619,7 +619,7 @@ impl<T> BTreeSet<T> {
619619
/// ```
620620
/// use std::collections::BTreeSet;
621621
///
622-
/// let sub: BTreeSet<_> = [1, 2].iter().cloned().collect();
622+
/// let sub: BTreeSet<_> = [1, 2].into_iter().collect();
623623
/// let mut set = BTreeSet::new();
624624
///
625625
/// assert_eq!(set.is_superset(&sub), false);
@@ -831,7 +831,7 @@ impl<T> BTreeSet<T> {
831831
/// ```
832832
/// use std::collections::BTreeSet;
833833
///
834-
/// let mut set: BTreeSet<_> = [1, 2, 3].iter().cloned().collect();
834+
/// let mut set: BTreeSet<_> = [1, 2, 3].into_iter().collect();
835835
/// assert_eq!(set.take(&2), Some(2));
836836
/// assert_eq!(set.take(&2), None);
837837
/// ```
@@ -985,7 +985,7 @@ impl<T> BTreeSet<T> {
985985
/// ```
986986
/// use std::collections::BTreeSet;
987987
///
988-
/// let set: BTreeSet<usize> = [1, 2, 3].iter().cloned().collect();
988+
/// let set: BTreeSet<usize> = [1, 2, 3].into_iter().collect();
989989
/// let mut set_iter = set.iter();
990990
/// assert_eq!(set_iter.next(), Some(&1));
991991
/// assert_eq!(set_iter.next(), Some(&2));
@@ -998,7 +998,7 @@ impl<T> BTreeSet<T> {
998998
/// ```
999999
/// use std::collections::BTreeSet;
10001000
///
1001-
/// let set: BTreeSet<usize> = [3, 1, 2].iter().cloned().collect();
1001+
/// let set: BTreeSet<usize> = [3, 1, 2].into_iter().collect();
10021002
/// let mut set_iter = set.iter();
10031003
/// assert_eq!(set_iter.next(), Some(&1));
10041004
/// assert_eq!(set_iter.next(), Some(&2));
@@ -1069,7 +1069,7 @@ impl<T> IntoIterator for BTreeSet<T> {
10691069
/// ```
10701070
/// use std::collections::BTreeSet;
10711071
///
1072-
/// let set: BTreeSet<usize> = [1, 2, 3, 4].iter().cloned().collect();
1072+
/// let set: BTreeSet<usize> = [1, 2, 3, 4].into_iter().collect();
10731073
///
10741074
/// let v: Vec<_> = set.into_iter().collect();
10751075
/// assert_eq!(v, [1, 2, 3, 4]);

Diff for: ‎library/alloc/src/collections/btree/set/tests.rs

+10-10
Original file line numberDiff line numberDiff line change
@@ -113,8 +113,8 @@ fn test_intersection() {
113113

114114
#[test]
115115
fn test_intersection_size_hint() {
116-
let x: BTreeSet<i32> = [3, 4].iter().copied().collect();
117-
let y: BTreeSet<i32> = [1, 2, 3].iter().copied().collect();
116+
let x: BTreeSet<i32> = [3, 4].into_iter().collect();
117+
let y: BTreeSet<i32> = [1, 2, 3].into_iter().collect();
118118
let mut iter = x.intersection(&y);
119119
assert_eq!(iter.size_hint(), (1, Some(1)));
120120
assert_eq!(iter.next(), Some(&3));
@@ -165,7 +165,7 @@ fn test_difference() {
165165

166166
#[test]
167167
fn test_difference_size_hint() {
168-
let s246: BTreeSet<i32> = [2, 4, 6].iter().copied().collect();
168+
let s246: BTreeSet<i32> = [2, 4, 6].into_iter().collect();
169169
let s23456: BTreeSet<i32> = (2..=6).collect();
170170
let mut iter = s246.difference(&s23456);
171171
assert_eq!(iter.size_hint(), (0, Some(3)));
@@ -241,8 +241,8 @@ fn test_symmetric_difference() {
241241

242242
#[test]
243243
fn test_symmetric_difference_size_hint() {
244-
let x: BTreeSet<i32> = [2, 4].iter().copied().collect();
245-
let y: BTreeSet<i32> = [1, 2, 3].iter().copied().collect();
244+
let x: BTreeSet<i32> = [2, 4].into_iter().collect();
245+
let y: BTreeSet<i32> = [1, 2, 3].into_iter().collect();
246246
let mut iter = x.symmetric_difference(&y);
247247
assert_eq!(iter.size_hint(), (0, Some(5)));
248248
assert_eq!(iter.next(), Some(&1));
@@ -269,8 +269,8 @@ fn test_union() {
269269

270270
#[test]
271271
fn test_union_size_hint() {
272-
let x: BTreeSet<i32> = [2, 4].iter().copied().collect();
273-
let y: BTreeSet<i32> = [1, 2, 3].iter().copied().collect();
272+
let x: BTreeSet<i32> = [2, 4].into_iter().collect();
273+
let y: BTreeSet<i32> = [1, 2, 3].into_iter().collect();
274274
let mut iter = x.union(&y);
275275
assert_eq!(iter.size_hint(), (3, Some(5)));
276276
assert_eq!(iter.next(), Some(&1));
@@ -338,8 +338,8 @@ fn test_retain() {
338338

339339
#[test]
340340
fn test_drain_filter() {
341-
let mut x: BTreeSet<_> = [1].iter().copied().collect();
342-
let mut y: BTreeSet<_> = [1].iter().copied().collect();
341+
let mut x: BTreeSet<_> = [1].into_iter().collect();
342+
let mut y: BTreeSet<_> = [1].into_iter().collect();
343343

344344
x.drain_filter(|_| true);
345345
y.drain_filter(|_| false);
@@ -423,7 +423,7 @@ fn test_zip() {
423423
fn test_from_iter() {
424424
let xs = [1, 2, 3, 4, 5, 6, 7, 8, 9];
425425

426-
let set: BTreeSet<_> = xs.iter().cloned().collect();
426+
let set: BTreeSet<_> = xs.into_iter().collect();
427427

428428
for x in &xs {
429429
assert!(set.contains(x));

Diff for: ‎library/alloc/src/vec/mod.rs

+4-4
Original file line numberDiff line numberDiff line change
@@ -887,7 +887,7 @@ impl<T, A: Allocator> Vec<T, A> {
887887
///
888888
/// ```
889889
/// let mut vec = Vec::with_capacity(10);
890-
/// vec.extend([1, 2, 3].iter().cloned());
890+
/// vec.extend([1, 2, 3]);
891891
/// assert_eq!(vec.capacity(), 10);
892892
/// vec.shrink_to_fit();
893893
/// assert!(vec.capacity() >= 3);
@@ -915,7 +915,7 @@ impl<T, A: Allocator> Vec<T, A> {
915915
/// ```
916916
/// #![feature(shrink_to)]
917917
/// let mut vec = Vec::with_capacity(10);
918-
/// vec.extend([1, 2, 3].iter().cloned());
918+
/// vec.extend([1, 2, 3]);
919919
/// assert_eq!(vec.capacity(), 10);
920920
/// vec.shrink_to(4);
921921
/// assert!(vec.capacity() >= 4);
@@ -948,7 +948,7 @@ impl<T, A: Allocator> Vec<T, A> {
948948
///
949949
/// ```
950950
/// let mut vec = Vec::with_capacity(10);
951-
/// vec.extend([1, 2, 3].iter().cloned());
951+
/// vec.extend([1, 2, 3]);
952952
///
953953
/// assert_eq!(vec.capacity(), 10);
954954
/// let slice = vec.into_boxed_slice();
@@ -2533,7 +2533,7 @@ impl<T, A: Allocator> Vec<T, A> {
25332533
/// ```
25342534
/// let mut v = vec![1, 2, 3];
25352535
/// let new = [7, 8];
2536-
/// let u: Vec<_> = v.splice(..2, new.iter().cloned()).collect();
2536+
/// let u: Vec<_> = v.splice(..2, new.into_iter()).collect();
25372537
/// assert_eq!(v, &[7, 8, 3]);
25382538
/// assert_eq!(u, &[1, 2]);
25392539
/// ```

Diff for: ‎library/alloc/tests/binary_heap.rs

+3-3
Original file line numberDiff line numberDiff line change
@@ -264,7 +264,7 @@ fn test_empty_peek_mut() {
264264
fn test_from_iter() {
265265
let xs = vec![9, 8, 7, 6, 5, 4, 3, 2, 1];
266266

267-
let mut q: BinaryHeap<_> = xs.iter().rev().cloned().collect();
267+
let mut q: BinaryHeap<_> = xs.iter().rev().copied().collect();
268268

269269
for &x in &xs {
270270
assert_eq!(q.pop().unwrap(), x);
@@ -273,7 +273,7 @@ fn test_from_iter() {
273273

274274
#[test]
275275
fn test_drain() {
276-
let mut q: BinaryHeap<_> = [9, 8, 7, 6, 5, 4, 3, 2, 1].iter().cloned().collect();
276+
let mut q: BinaryHeap<_> = [9, 8, 7, 6, 5, 4, 3, 2, 1].into_iter().collect();
277277

278278
assert_eq!(q.drain().take(5).count(), 5);
279279

@@ -282,7 +282,7 @@ fn test_drain() {
282282

283283
#[test]
284284
fn test_drain_sorted() {
285-
let mut q: BinaryHeap<_> = [9, 8, 7, 6, 5, 4, 3, 2, 1].iter().cloned().collect();
285+
let mut q: BinaryHeap<_> = [9, 8, 7, 6, 5, 4, 3, 2, 1].into_iter().collect();
286286

287287
assert_eq!(q.drain_sorted().take(5).collect::<Vec<_>>(), vec![9, 8, 7, 6, 5]);
288288

Diff for: ‎library/alloc/tests/linked_list.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -304,7 +304,7 @@ fn test_show() {
304304
let list: LinkedList<_> = (0..10).collect();
305305
assert_eq!(format!("{:?}", list), "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]");
306306

307-
let list: LinkedList<_> = vec!["just", "one", "test", "more"].iter().cloned().collect();
307+
let list: LinkedList<_> = vec!["just", "one", "test", "more"].into_iter().collect();
308308
assert_eq!(format!("{:?}", list), "[\"just\", \"one\", \"test\", \"more\"]");
309309
}
310310

Diff for: ‎library/alloc/tests/string.rs

+1-2
Original file line numberDiff line numberDiff line change
@@ -154,8 +154,7 @@ fn test_from_utf16() {
154154
(String::from("\u{20000}"), vec![0xD840, 0xDC00]),
155155
];
156156

157-
for p in &pairs {
158-
let (s, u) = (*p).clone();
157+
for (s, u) in pairs {
159158
let s_as_utf16 = s.encode_utf16().collect::<Vec<u16>>();
160159
let u_as_string = String::from_utf16(&u).unwrap();
161160

Diff for: ‎library/alloc/tests/vec.rs

+7-7
Original file line numberDiff line numberDiff line change
@@ -458,7 +458,7 @@ fn test_partition() {
458458
fn test_zip_unzip() {
459459
let z1 = vec![(1, 4), (2, 5), (3, 6)];
460460

461-
let (left, right): (Vec<_>, Vec<_>) = z1.iter().cloned().unzip();
461+
let (left, right): (Vec<_>, Vec<_>) = z1.into_iter().unzip();
462462

463463
assert_eq!((1, 4), (left[0], right[0]));
464464
assert_eq!((2, 5), (left[1], right[1]));
@@ -793,7 +793,7 @@ fn test_drain_leak() {
793793
fn test_splice() {
794794
let mut v = vec![1, 2, 3, 4, 5];
795795
let a = [10, 11, 12];
796-
v.splice(2..4, a.iter().cloned());
796+
v.splice(2..4, a.into_iter());
797797
assert_eq!(v, &[1, 2, 10, 11, 12, 5]);
798798
v.splice(1..3, Some(20));
799799
assert_eq!(v, &[1, 20, 11, 12, 5]);
@@ -803,7 +803,7 @@ fn test_splice() {
803803
fn test_splice_inclusive_range() {
804804
let mut v = vec![1, 2, 3, 4, 5];
805805
let a = [10, 11, 12];
806-
let t1: Vec<_> = v.splice(2..=3, a.iter().cloned()).collect();
806+
let t1: Vec<_> = v.splice(2..=3, a.into_iter()).collect();
807807
assert_eq!(v, &[1, 2, 10, 11, 12, 5]);
808808
assert_eq!(t1, &[3, 4]);
809809
let t2: Vec<_> = v.splice(1..=2, Some(20)).collect();
@@ -816,22 +816,22 @@ fn test_splice_inclusive_range() {
816816
fn test_splice_out_of_bounds() {
817817
let mut v = vec![1, 2, 3, 4, 5];
818818
let a = [10, 11, 12];
819-
v.splice(5..6, a.iter().cloned());
819+
v.splice(5..6, a.into_iter());
820820
}
821821

822822
#[test]
823823
#[should_panic]
824824
fn test_splice_inclusive_out_of_bounds() {
825825
let mut v = vec![1, 2, 3, 4, 5];
826826
let a = [10, 11, 12];
827-
v.splice(5..=5, a.iter().cloned());
827+
v.splice(5..=5, a.into_iter());
828828
}
829829

830830
#[test]
831831
fn test_splice_items_zero_sized() {
832832
let mut vec = vec![(), (), ()];
833833
let vec2 = vec![];
834-
let t: Vec<_> = vec.splice(1..2, vec2.iter().cloned()).collect();
834+
let t: Vec<_> = vec.splice(1..2, vec2.into_iter()).collect();
835835
assert_eq!(vec, &[(), ()]);
836836
assert_eq!(t, &[()]);
837837
}
@@ -848,7 +848,7 @@ fn test_splice_unbounded() {
848848
fn test_splice_forget() {
849849
let mut v = vec![1, 2, 3, 4, 5];
850850
let a = [10, 11, 12];
851-
std::mem::forget(v.splice(2..4, a.iter().cloned()));
851+
std::mem::forget(v.splice(2..4, a.into_iter()));
852852
assert_eq!(v, &[1, 2]);
853853
}
854854

Diff for: ‎library/alloc/tests/vec_deque.rs

+5-5
Original file line numberDiff line numberDiff line change
@@ -497,7 +497,7 @@ fn test_drain() {
497497
#[test]
498498
fn test_from_iter() {
499499
let v = vec![1, 2, 3, 4, 5, 6, 7];
500-
let deq: VecDeque<_> = v.iter().cloned().collect();
500+
let deq: VecDeque<_> = v.iter().copied().collect();
501501
let u: Vec<_> = deq.iter().cloned().collect();
502502
assert_eq!(u, v);
503503

@@ -648,7 +648,7 @@ fn test_show() {
648648
let ringbuf: VecDeque<_> = (0..10).collect();
649649
assert_eq!(format!("{:?}", ringbuf), "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]");
650650

651-
let ringbuf: VecDeque<_> = vec!["just", "one", "test", "more"].iter().cloned().collect();
651+
let ringbuf: VecDeque<_> = vec!["just", "one", "test", "more"].into_iter().collect();
652652
assert_eq!(format!("{:?}", ringbuf), "[\"just\", \"one\", \"test\", \"more\"]");
653653
}
654654

@@ -1462,7 +1462,7 @@ fn test_rotate_left_random() {
14621462
let n = 12;
14631463
let mut v: VecDeque<_> = (0..n).collect();
14641464
let mut total_shift = 0;
1465-
for shift in shifts.iter().cloned() {
1465+
for shift in shifts {
14661466
v.rotate_left(shift);
14671467
total_shift += shift;
14681468
for i in 0..n {
@@ -1480,7 +1480,7 @@ fn test_rotate_right_random() {
14801480
let n = 12;
14811481
let mut v: VecDeque<_> = (0..n).collect();
14821482
let mut total_shift = 0;
1483-
for shift in shifts.iter().cloned() {
1483+
for shift in shifts {
14841484
v.rotate_right(shift);
14851485
total_shift += shift;
14861486
for i in 0..n {
@@ -1514,7 +1514,7 @@ fn test_try_fold_unit() {
15141514

15151515
#[test]
15161516
fn test_try_fold_unit_none() {
1517-
let v: std::collections::VecDeque<()> = [(); 10].iter().cloned().collect();
1517+
let v: std::collections::VecDeque<()> = [(); 10].into_iter().collect();
15181518
let mut iter = v.into_iter();
15191519
assert!(iter.try_fold((), |_, _| None).is_none());
15201520
assert_eq!(iter.len(), 9);

Diff for: ‎library/core/src/char/decode.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -38,7 +38,7 @@ pub struct DecodeUtf16Error {
3838
/// ];
3939
///
4040
/// assert_eq!(
41-
/// decode_utf16(v.iter().cloned())
41+
/// decode_utf16(v)
4242
/// .map(|r| r.map_err(|e| e.unpaired_surrogate()))
4343
/// .collect::<Vec<_>>(),
4444
/// vec![
@@ -62,7 +62,7 @@ pub struct DecodeUtf16Error {
6262
/// ];
6363
///
6464
/// assert_eq!(
65-
/// decode_utf16(v.iter().cloned())
65+
/// decode_utf16(v)
6666
/// .map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))
6767
/// .collect::<String>(),
6868
/// "𝄞mus�ic�"

Diff for: ‎library/core/src/char/methods.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -58,7 +58,7 @@ impl char {
5858
/// ];
5959
///
6060
/// assert_eq!(
61-
/// decode_utf16(v.iter().cloned())
61+
/// decode_utf16(v)
6262
/// .map(|r| r.map_err(|e| e.unpaired_surrogate()))
6363
/// .collect::<Vec<_>>(),
6464
/// vec![
@@ -82,7 +82,7 @@ impl char {
8282
/// ];
8383
///
8484
/// assert_eq!(
85-
/// decode_utf16(v.iter().cloned())
85+
/// decode_utf16(v)
8686
/// .map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))
8787
/// .collect::<String>(),
8888
/// "𝄞mus�ic�"

0 commit comments

Comments
 (0)