Lines Matching refs:iter
7 b.iter(|| {
8 let _: LinkedList<_> = v.iter().cloned().collect();
15 b.iter(|| {
23 b.iter(|| {
31 b.iter(|| {
40 b.iter(|| {
49 let m: LinkedList<_> = v.iter().cloned().collect();
50 b.iter(|| {
51 assert!(m.iter().count() == 128);
57 let mut m: LinkedList<_> = v.iter().cloned().collect();
58 b.iter(|| {
65 let m: LinkedList<_> = v.iter().cloned().collect();
66 b.iter(|| {
67 assert!(m.iter().rev().count() == 128);
73 let mut m: LinkedList<_> = v.iter().cloned().collect();
74 b.iter(|| {
84 b.iter(|| s.chars().count());
91 b.iter(|| {
107 b.iter(|| s.chars().count());
114 b.iter(|| s.chars().rev().count());
121 b.iter(|| {
133 b.iter(|| assert_eq!(s.char_indices().count(), len));
141 b.iter(|| assert_eq!(s.char_indices().rev().count(), len));
148 b.iter(|| assert_eq!(s.split('V').count(), 3));
156 b.iter(|| assert_eq!(s.split(' ').count(), len));
167 b.iter(|| assert_eq!(s.split(pred).count(), len));
175 b.iter(|| assert_eq!(s.split(|c: char| c == ' ').count(), len));
184 b.iter(|| assert_eq!(s.split(c).count(), len));
192 b.iter(|| {
202 b.iter(|| {
246 b.iter(|| {
256 b.iter(|| {
266 b.iter(|| {
277 bencher.iter(|| {
377 use std::iter::repeat;
382 b.iter(|| String::with_capacity(100));
388 b.iter(|| {
399 b.iter(|| {
410 b.iter(|| {
421 b.iter(|| {
435 b.iter(|| {
444 b.iter(|| {
452 b.iter(|| {
460 b.iter(|| {
473 b.iter(|| {
485 b.iter(|| String::from(s))
492 b.iter(|| String::from(s))
499 b.iter(|| s.to_string())
505 b.iter(|| {
515 b.iter(|| {
525 b.iter(|| {
535 b.iter(|| {
542 use std::iter::{repeat, FromIterator};
547 b.iter(|| Vec::<u32>::new())
553 b.iter(|| Vec::<u32>::with_capacity(src_len))
579 b.iter(|| (0..src_len).collect::<Vec<_>>())
605 b.iter(|| repeat(5).take(src_len).collect::<Vec<usize>>())
633 b.iter(|| src.as_slice().to_vec());
661 b.iter(|| {
662 let dst: Vec<_> = FromIterator::from_iter(src.iter().cloned());
693 b.iter(|| {
741 b.iter(|| {
752 b.iter(|| {
802 b.iter(|| src.clone());
831 b.iter(|| {
967 b.iter(|| {
1004 b.iter(|| {
1024 b.iter(|| {
1028 .zip(subst.iter().copied())
1043 b.iter(|| {
1060 b.iter(|| {
1079 let v: Vec<Droppable> = std::iter::repeat_with(|| Droppable(0)).take(1000).collect();
1080 b.iter(|| {
1095 b.iter(|| data.iter().cloned().chain([1].iter().cloned()).collect::<Vec<_>>());
1101 b.iter(|| {
1102 data.iter()
1104 .chain([1].iter().cloned())
1105 .chain([2].iter().cloned())
1113 b.iter(|| {
1114 data.iter().cloned().chain([1].iter().chain([2].iter()).cloned()).collect::<Vec<_>>()
1120 b.iter(|| (0..LEN).map(|_| u32::default()).collect::<Vec<_>>());
1126 b.iter(|| {
1128 v.extend(data.iter().chain([1].iter()));
1136 b.iter(|| {
1138 v.extend(data.iter().cloned().chain(Some(1)));
1146 b.iter(|| {
1148 v.extend(data.iter().rev());
1156 b.iter(|| {
1158 v.extend(data.iter().rev());
1166 b.iter(|| {
1168 v.extend(data.iter().map(|t| t.1));
1176 b.iter(|| {
1214 b.iter(|| {
1233 b.iter(|| {
1296 use std::iter::Iterator;
1318 b.iter(|| {
1341 b.iter(|| {
1370 b.iter(|| {
1393 b.iter(|| {
1422 b.iter(|| {
1452 b.iter(|| {
1476 b.iter(|| {
1508 b.iter(|| {
1542 b.iter(|| {
1544 black_box(map.iter());
1549 /// Contrast range_unbounded_unbounded with `iter()`.
1596 b.iter(|| src.clone())
1602 b.iter(|| src.clone().clear())
1608 b.iter(|| src.clone().drain_filter(|_, _| true).count())
1614 b.iter(|| {
1624 b.iter(|| src.clone().into_iter().count())
1630 b.iter(|| {
1640 b.iter(|| {
1642 while let Some(elt) = map.iter().map(|(&i, _)| i).next() {
1653 b.iter(|| {
1667 b.iter(|| src.clone())
1673 b.iter(|| src.clone().clear())
1679 b.iter(|| src.clone().drain_filter(|_, _| true).count())
1685 b.iter(|| {
1695 b.iter(|| src.clone().into_iter().count())
1701 b.iter(|| {
1711 b.iter(|| {
1713 while let Some(elt) = map.iter().map(|(&i, _)| i).next() {
1724 b.iter(|| {
1738 b.iter(|| src.clone())
1744 b.iter(|| src.clone().clear())
1750 b.iter(|| src.clone().drain_filter(|_, _| true).count())
1756 b.iter(|| {
1766 b.iter(|| src.clone().into_iter().count())
1772 b.iter(|| {
1782 b.iter(|| {
1784 while let Some(elt) = map.iter().map(|(&i, _)| i).next() {
1795 b.iter(|| {
1852 b.iter(|| sets[0].$set_func(&sets[1]).$result_func())
1864 b.iter(|| src.clone())
1870 b.iter(|| src.clone().clear())
1876 b.iter(|| src.clone().drain_filter(|_| true).count())
1882 b.iter(|| {
1892 b.iter(|| src.clone().into_iter().count())
1898 b.iter(|| {
1908 b.iter(|| {
1910 while let Some(elt) = set.iter().copied().next() {
1921 b.iter(|| {
1935 b.iter(|| src.clone())
1941 b.iter(|| src.clone().clear())
1947 b.iter(|| src.clone().drain_filter(|_| true).count())
1953 b.iter(|| {
1963 b.iter(|| src.clone().into_iter().count())
1969 b.iter(|| {
1979 b.iter(|| {
1981 while let Some(elt) = set.iter().copied().next() {
1992 b.iter(|| {
2044 b.iter(|| {
2060 b.iter(|| {
2072 b.iter(|| {
2080 b.iter(|| xss.join(&0));
2086 b.iter(|| {
2095 b.iter(|| vec.starts_with(&vec))
2101 b.iter(|| vec.starts_with(&vec))
2109 b.iter(|| vec.starts_with(&match_vec))
2115 b.iter(|| vec.ends_with(&vec))
2121 b.iter(|| vec.ends_with(&vec))
2129 b.iter(|| vec.starts_with(&match_vec))
2135 b.iter(|| vec.contains(&99))
2140 b.iter(|| vec![0u8; 1024]);
2145 b.iter(|| {
2158 b.iter(|| {
2171 b.iter(|| {
2186 b.iter(|| {
2198 b.iter(|| {
2269 b.iter(|| v.clone().$f());
2280 let v = v.iter().map(|s| &**s).collect::<Vec<&str>>();
2281 b.iter(|| v.clone().$f());
2292 b.iter(|| {
2314 b.iter(|| v.clone().$f(|x| x.to_string()));
2359 b.iter(|| black_box(&mut v[1..]).reverse());
2384 b.iter(|| black_box(&mut v).rotate_left(($mid * 8 + size - 1) / size));
2418 b.iter(|| {
2426 b.iter(|| {
2439 b.iter(|| {
2452 b.iter(|| {
2465 b.iter(|| black_box(ring.iter().try_fold(0, |a, b| Some(a + b))))
2478 b.iter(|| {
2479 let mut iter = vec.iter().copied();
2480 let mut heap: BinaryHeap<_> = iter.by_ref().take(1000).collect();
2482 for x in iter {
2500 b.iter(|| {
2506 for &i in vec.iter() {
2520 b.iter(|| BinaryHeap::from(vec.clone()))
2527 b.iter(|| bheap.clone().into_sorted_vec())
2537 b.iter(|| {
2538 for &i in vec.iter() {
2550 b.iter(|| {
2590 println!("\ncustom-bench vec_deque_append {:?} ns/iter\n", median.as_nanos());
2640 v.iter().cloned().collect()
2702 for (i, elt) in m.iter().enumerate() {
2706 assert_eq!(n.iter().next(), None);
2708 let mut it = n.iter();
2721 let mut it = n.iter();
2732 assert_eq!(n.iter().next(), None);
2736 let mut it = n.iter();
2750 for (i, elt) in m.iter().rev().enumerate() {
2754 assert_eq!(n.iter().rev().next(), None);
2756 let mut it = n.iter().rev();
2898 let list: LinkedList<_> = vec!["just", "one", "test", "more"].iter().cloned().collect();
2928 assert!(a.iter().eq(&[1, 2, 3, 4]));
2934 assert!(a.iter().eq(&[1, 2, 3, 4, 5, 6, 7]));
2955 let mut iter = list.drain_filter(|_| true);
2956 assert_eq!(iter.size_hint(), (0, Some(0)));
2957 assert_eq!(iter.next(), None);
2958 assert_eq!(iter.size_hint(), (0, Some(0)));
2959 assert_eq!(iter.next(), None);
2960 assert_eq!(iter.size_hint(), (0, Some(0)));
2974 let mut iter = list.drain_filter(|_| true);
2975 assert_eq!(iter.size_hint(), (0, Some(initial_len)));
2976 while let Some(_) = iter.next() {
2978 assert_eq!(iter.size_hint(), (0, Some(initial_len - count)));
2980 assert_eq!(iter.size_hint(), (0, Some(0)));
2981 assert_eq!(iter.next(), None);
2982 assert_eq!(iter.size_hint(), (0, Some(0)));
2998 let mut iter = list.drain_filter(|_| false);
2999 assert_eq!(iter.size_hint(), (0, Some(initial_len)));
3000 for _ in iter.by_ref() {
3003 assert_eq!(iter.size_hint(), (0, Some(0)));
3004 assert_eq!(iter.next(), None);
3005 assert_eq!(iter.size_hint(), (0, Some(0)));
3021 let mut iter = list.drain_filter(|_| true);
3022 assert_eq!(iter.size_hint(), (0, Some(initial_len)));
3023 while let Some(_) = iter.next() {
3025 assert_eq!(iter.size_hint(), (0, Some(initial_len - count)));
3027 assert_eq!(iter.size_hint(), (0, Some(0)));
3028 assert_eq!(iter.next(), None);
3029 assert_eq!(iter.size_hint(), (0, Some(0)));
3300 use std::iter::TrustedLen;
3401 let iter = (0..SHARED_ITER_MAX).filter(|x| x % 2 == 0).map(Box::new);
3404 let vec = iter.clone().collect::<Vec<_>>();
3405 let rc = iter.collect::<Rc<[_]>>();
3422 let iter = (0..SHARED_ITER_MAX).map(Box::new);
3423 assert_trusted_len(&iter);
3426 let vec = iter.clone().collect::<Vec<_>>();
3427 let rc = iter.collect::<Rc<[_]>>();
3441 let iter = (0..SHARED_ITER_MAX).map(drop);
3442 let vec = iter.clone().collect::<Vec<_>>();
3443 let rc = iter.collect::<Rc<[_]>>();
3459 let iter = (0..SHARED_ITER_MAX).map(|val| match val {
3463 assert_trusted_len(&iter);
3464 let _ = iter.collect::<Rc<[_]>>();
3490 let iter = Iter(vec.into_iter());
3491 assert_trusted_len(&iter);
3492 assert_eq!(&[Box::new(42), Box::new(24)], &*iter.collect::<Rc<[_]>>());
4083 let mut iter = 0..=5;
4084 iter.by_ref().count(); // exhaust it
4085 iter
4091 let mut iter = 0..=6;
4092 iter.by_ref().count(); // exhaust it
4093 iter
4954 v.iter().map(|x| x.len()).sum()
5264 for (i, e) in right.iter().enumerate() {
5572 let s: String = chs.iter().cloned().collect();
5578 assert_eq!(schs.iter().cloned().collect::<String>(), s);
5776 assert!(core::char::decode_utf16(u.iter().cloned()).all(|r| r.is_ok()));
6534 use std::iter::InPlaceIterable;
6668 assert!(v.iter().eq(w.iter().chain(w.iter())));
6834 assert!(v.iter().all(|r| Rc::strong_count(r) == 1));
6849 assert!(v.iter().all(|r| Rc::strong_count(r) == 1));
6866 let mut v = v.iter().map(|r| Wrap(r.clone())).collect::<Vec<_>>();
6878 assert!(v.iter().all(|r| Rc::strong_count(r) == 1));
6957 assert_eq!(v.iter().count(), 0);
6959 assert_eq!(v.iter().count(), 1);
6961 assert_eq!(v.iter().count(), 2);
6990 let (left, right): (Vec<_>, Vec<_>) = z1.iter().cloned().unzip();
7325 v.splice(2..4, a.iter().cloned());
7335 let t1: Vec<_> = v.splice(2..=3, a.iter().cloned()).collect();
7348 v.splice(5..6, a.iter().cloned());
7356 v.splice(5..=5, a.iter().cloned());
7363 let t: Vec<_> = vec.splice(1..2, vec2.iter().cloned()).collect();
7380 std::mem::forget(v.splice(2..4, a.iter().cloned()));
7514 let mut iter = src.into_iter();
7515 iter.next();
7516 iter.next();
7517 let sink = iter.collect::<Vec<_>>();
7527 let iter = src
7531 .zip(std::iter::repeat(1usize))
7537 assert_in_place_trait(&iter);
7538 let sink = iter.collect::<Result<Vec<_>, _>>().unwrap();
7546 let src: Vec<_> = drop_count.iter().cloned().collect();
7548 let iter = src.into_iter();
7549 let sink: Vec<_> = iter.skip(1).take(1).collect();
7561 let src: Vec<_> = drop_count.iter().cloned().collect();
7562 let iter = src.into_iter();
7565 let _ = iter
7577 drop_count.iter().map(Rc::strong_count).all(|count| count == 1),
7691 let mut iter = vec.drain_filter(|_| true);
7692 assert_eq!(iter.size_hint(), (0, Some(0)));
7693 assert_eq!(iter.next(), None);
7694 assert_eq!(iter.size_hint(), (0, Some(0)));
7695 assert_eq!(iter.next(), None);
7696 assert_eq!(iter.size_hint(), (0, Some(0)));
7708 let mut iter = vec.drain_filter(|_| true);
7709 assert_eq!(iter.size_hint(), (0, Some(initial_len)));
7710 while let Some(_) = iter.next() {
7712 assert_eq!(iter.size_hint(), (0, Some(initial_len - count)));
7714 assert_eq!(iter.size_hint(), (0, Some(0)));
7715 assert_eq!(iter.next(), None);
7716 assert_eq!(iter.size_hint(), (0, Some(0)));
7731 let mut iter = vec.drain_filter(|_| false);
7732 assert_eq!(iter.size_hint(), (0, Some(initial_len)));
7733 for _ in iter.by_ref() {
7736 assert_eq!(iter.size_hint(), (0, Some(0)));
7737 assert_eq!(iter.next(), None);
7738 assert_eq!(iter.size_hint(), (0, Some(0)));
7753 let mut iter = vec.drain_filter(|_| true);
7754 assert_eq!(iter.size_hint(), (0, Some(initial_len)));
7755 while let Some(_) = iter.next() {
7757 assert_eq!(iter.size_hint(), (0, Some(initial_len - count)));
7759 assert_eq!(iter.size_hint(), (0, Some(0)));
7760 assert_eq!(iter.next(), None);
7761 assert_eq!(iter.size_hint(), (0, Some(0)));
7885 for (index, count) in drop_counts.iter().cloned().enumerate() {
7936 for (index, count) in drop_counts.iter().cloned().enumerate() {
8234 v.extend(std::iter::once(3)); // `TrustedLen` specialization
8235 v.extend(std::iter::empty::<i32>()); // `TrustedLen` specialization with empty iterator
8236 v.extend(std::iter::once(3).filter(|_| true)); // base case
8237 v.extend(std::iter::once(&3)); // `cloned` specialization
8579 assert_eq!(tester.iter().count(), len);
8741 let iter = (0..8).map(move |bit| (x >> bit) & 1 == 1);
8742 vec.extend(iter);
8798 let ok = vec.iter().zip(expected.iter()).all(|(x, y)| x.index == y.index);
9057 use std::iter::TrustedLen;
9154 let iter = (0..SHARED_ITER_MAX).filter(|x| x % 2 == 0).map(Box::new);
9157 let vec = iter.clone().collect::<Vec<_>>();
9158 let rc = iter.collect::<Rc<[_]>>();
9175 let iter = (0..SHARED_ITER_MAX).map(Box::new);
9176 assert_trusted_len(&iter);
9179 let vec = iter.clone().collect::<Vec<_>>();
9180 let rc = iter.collect::<Rc<[_]>>();
9194 let iter = (0..SHARED_ITER_MAX).map(drop);
9195 let vec = iter.clone().collect::<Vec<_>>();
9196 let rc = iter.collect::<Rc<[_]>>();
9212 let iter = (0..SHARED_ITER_MAX).map(|val| match val {
9216 assert_trusted_len(&iter);
9217 let _ = iter.collect::<Rc<[_]>>();
9243 let iter = Iter(vec.into_iter());
9244 assert_trusted_len(&iter);
9245 assert_eq!(&[Box::new(42), Box::new(24)], &*iter.collect::<Rc<[_]>>());
9972 let mut it = xs.iter();
9990 assert_eq!(xs.iter().size_hint(), (5, Some(5)));
9997 let mut iter = xs.iter();
9998 assert_eq!(iter.as_slice(), &[1, 2, 5, 10, 11]);
9999 iter.next();
10000 assert_eq!(iter.as_slice(), &[2, 5, 10, 11]);
10006 let mut iter = xs.iter();
10007 assert_eq!(iter.as_ref(), &[1, 2, 5, 10, 11]);
10008 iter.next();
10009 assert_eq!(iter.as_ref(), &[2, 5, 10, 11]);
10015 let mut it = xs.iter();
10028 assert_eq!(xs[i..j].iter().is_empty(), xs[i..j].is_empty());
10047 for &x in xs.iter().rev() {
10955 for (i, c) in DROP_COUNTS.iter().enumerate().take(len) {
11152 let mut iter = slice.group_by(|a, b| a == b);
11153 assert_eq!(iter.next(), Some(&[1, 1, 1][..]));
11154 assert_eq!(iter.next(), Some(&[3, 3][..]));
11155 assert_eq!(iter.next(), Some(&[2, 2, 2][..]));
11156 assert_eq!(iter.next(), Some(&[1][..]));
11157 assert_eq!(iter.next(), Some(&[0][..]));
11158 assert_eq!(iter.next(), None);
11160 let mut iter = slice.group_by(|a, b| a == b);
11161 assert_eq!(iter.next_back(), Some(&[0][..]));
11162 assert_eq!(iter.next_back(), Some(&[1][..]));
11163 assert_eq!(iter.next_back(), Some(&[2, 2, 2][..]));
11164 assert_eq!(iter.next_back(), Some(&[3, 3][..]));
11165 assert_eq!(iter.next_back(), Some(&[1, 1, 1][..]));
11166 assert_eq!(iter.next_back(), None);
11168 let mut iter = slice.group_by(|a, b| a == b);
11169 assert_eq!(iter.next(), Some(&[1, 1, 1][..]));
11170 assert_eq!(iter.next_back(), Some(&[0][..]));
11171 assert_eq!(iter.next(), Some(&[3, 3][..]));
11172 assert_eq!(iter.next_back(), Some(&[1][..]));
11173 assert_eq!(iter.next(), Some(&[2, 2, 2][..]));
11174 assert_eq!(iter.next_back(), None);
11181 let mut iter = slice.group_by_mut(|a, b| a == b);
11182 assert_eq!(iter.next(), Some(&mut [1, 1, 1][..]));
11183 assert_eq!(iter.next(), Some(&mut [3, 3][..]));
11184 assert_eq!(iter.next(), Some(&mut [2, 2, 2][..]));
11185 assert_eq!(iter.next(), Some(&mut [1][..]));
11186 assert_eq!(iter.next(), Some(&mut [0][..]));
11187 assert_eq!(iter.next(), None);
11189 let mut iter = slice.group_by_mut(|a, b| a == b);
11190 assert_eq!(iter.next_back(), Some(&mut [0][..]));
11191 assert_eq!(iter.next_back(), Some(&mut [1][..]));
11192 assert_eq!(iter.next_back(), Some(&mut [2, 2, 2][..]));
11193 assert_eq!(iter.next_back(), Some(&mut [3, 3][..]));
11194 assert_eq!(iter.next_back(), Some(&mut [1, 1, 1][..]));
11195 assert_eq!(iter.next_back(), None);
11197 let mut iter = slice.group_by_mut(|a, b| a == b);
11198 assert_eq!(iter.next(), Some(&mut [1, 1, 1][..]));
11199 assert_eq!(iter.next_back(), Some(&mut [0][..]));
11200 assert_eq!(iter.next(), Some(&mut [3, 3][..]));
11201 assert_eq!(iter.next_back(), Some(&mut [1][..]));
11202 assert_eq!(iter.next(), Some(&mut [2, 2, 2][..]));
11203 assert_eq!(iter.next_back(), None);
11459 assert_eq!(d.iter().cloned().collect::<Vec<_>>(), [4, 2, 3, 1]);
11465 assert_eq!(d.iter().next(), None);
11466 assert_eq!(d.iter().size_hint(), (0, Some(0)));
11473 assert_eq!(d.iter().collect::<Vec<_>>(), b);
11481 assert_eq!(d.iter().collect::<Vec<_>>(), b);
11484 let mut it = d.iter();
11500 assert_eq!(d.iter().rev().next(), None);
11507 assert_eq!(d.iter().rev().collect::<Vec<_>>(), b);
11514 assert_eq!(d.iter().rev().collect::<Vec<_>>(), b);
11579 // Empty iter
11582 let mut iter = d.into_iter();
11584 assert_eq!(iter.size_hint(), (0, Some(0)));
11585 assert_eq!(iter.next(), None);
11586 assert_eq!(iter.size_hint(), (0, Some(0)));
11589 // simple iter
11600 // wrapped iter
11637 // Empty iter
11642 let mut iter = d.drain(..);
11644 assert_eq!(iter.size_hint(), (0, Some(0)));
11645 assert_eq!(iter.next(), None);
11646 assert_eq!(iter.size_hint(), (0, Some(0)));
11652 // simple iter
11663 // wrapped iter
11704 let deq: VecDeque<_> = v.iter().cloned().collect();
11705 let u: Vec<_> = deq.iter().cloned().collect();
11710 for (i, &x) in deq.iter().enumerate() {
11855 let ringbuf: VecDeque<_> = vec!["just", "one", "test", "more"].iter().cloned().collect();
12138 assert_eq!(a.iter().cloned().collect::<Vec<_>>(), [1, 2, 3, 4, 5, 6]);
12139 assert_eq!(b.iter().cloned().collect::<Vec<_>>(), []);
12143 assert_eq!(a.iter().cloned().collect::<Vec<_>>(), [1, 2, 3, 4, 5, 6]);
12144 assert_eq!(b.iter().cloned().collect::<Vec<_>>(), []);
12148 assert_eq!(b.iter().cloned().collect::<Vec<_>>(), [1, 2, 3, 4, 5, 6]);
12149 assert_eq!(a.iter().cloned().collect::<Vec<_>>(), []);
12211 .iter()
12212 .chain(src.iter())
12312 assert!(v.iter().is_empty());
12316 assert!(!v.iter().is_empty());
12320 assert_eq!(v.iter().is_empty(), v.iter().len() == 0);
12324 assert!(v.iter().is_empty());
12669 for shift in shifts.iter().cloned() {
12687 for shift in shifts.iter().cloned() {
12698 assert_eq!(Some(0), VecDeque::<u32>::new().iter().try_fold(0, |_, _| None));
12715 let v: VecDeque<()> = std::iter::repeat(()).take(42).collect();
12721 let v: std::collections::VecDeque<()> = [(); 10].iter().cloned().collect();
12722 let mut iter = v.into_iter();
12723 assert!(iter.try_fold((), |_, _| None).is_none());
12724 assert_eq!(iter.len(), 9);
12736 assert_eq!(Ok::<_, ()>(66), v.iter().try_fold(0, |a, b| Ok(a + b)));
12742 let v: VecDeque<_> = [10, 20, 30, 40, 100, 60, 70, 80, 90].iter().collect();
12743 let mut iter = v.into_iter();
12744 assert_eq!(iter.try_fold(0_i8, |acc, &x| acc.checked_add(x)), None);
12745 assert_eq!(iter.next(), Some(&60));
12756 let mut iter = v.iter();
12757 let _ = iter.try_fold(0, |_, _| Some(1));
12758 assert!(iter.is_empty());
12769 let mut iter = v.iter();
12770 let _ = iter.find(|&&x| x == 2);
12771 assert_eq!(Some(&7), iter.next());
12783 assert_eq!(Ok::<_, ()>(66), v.iter().try_rfold(0, |a, b| Ok(a + b)));
12789 let v: VecDeque<_> = [10, 20, 30, 40, 100, 60, 70, 80, 90].iter().collect();
12790 let mut iter = v.into_iter();
12791 assert_eq!(iter.try_rfold(0_i8, |acc, &x| acc.checked_add(x)), None);
12792 assert_eq!(iter.next_back(), Some(&70));
12948 assert_eq!(tester.iter().count(), len);
13285 use std::iter::TrustedLen;
13307 let v: Vec<_> = pq.iter().rev().cloned().collect();
13381 check_exact_size_iterator(heap.len(), heap.iter());
13520 let heap_ptr = heap.iter().next().unwrap() as *const usize;
13549 let mut q: BinaryHeap<_> = xs.iter().rev().cloned().collect();
13558 let mut q: BinaryHeap<_> = [9, 8, 7, 6, 5, 4, 3, 2, 1].iter().cloned().collect();
13567 let mut q: BinaryHeap<_> = [9, 8, 7, 6, 5, 4, 3, 2, 1].iter().cloned().collect();
13739 data.iter().filter(|&&x| x != i).map(|&x| PanicOrd(x, false)).collect();
15000 use core::iter::FusedIterator;
15065 ($separator:expr, $target:expr, $iter:expr; $($num:expr),*) => {{
15067 let iter = $iter;
15074 for s in iter {
15083 for s in iter {
15118 let mut iter = slice.iter();
15121 let first = match iter.next() {
15131 .checked_mul(iter.len())
15133 slice.iter().map(|s| s.borrow().as_ref().len()).try_fold(n, usize::checked_add)
15150 let remain = specialize_for_lengths!(sep, target, iter; 0, 1, 2, 3, 4);
15367 fn case_ignoreable_then_cased<I: Iterator<Item = char>>(iter: I) -> bool {
15369 match iter.skip_while(|&c| Case_Ignorable(c)).next() {
16219 use core::iter::{FromIterator, FusedIterator};
16711 let mut iter = lossy::Utf8Lossy::from_bytes(v).chunks();
16713 let (first_valid, first_broken) = if let Some(chunk) = iter.next() {
16732 for lossy::Utf8LossyChunk { valid, broken } in iter {
16766 for c in decode_utf16(v.iter().cloned()) {
16803 decode_utf16(v.iter().cloned()).map(|r| r.unwrap_or(REPLACEMENT_CHARACTER)).collect()
17758 Drain { start, end, iter: chars_iter, string: self_ptr }
17935 fn from_iter<I: IntoIterator<Item = char>>(iter: I) -> String {
17937 buf.extend(iter);
17944 fn from_iter<I: IntoIterator<Item = &'a char>>(iter: I) -> String {
17946 buf.extend(iter);
17953 fn from_iter<I: IntoIterator<Item = &'a str>>(iter: I) -> String {
17955 buf.extend(iter);
17962 fn from_iter<I: IntoIterator<Item = String>>(iter: I) -> String {
17963 let mut iterator = iter.into_iter();
17980 fn from_iter<I: IntoIterator<Item = Box<str>>>(iter: I) -> String {
17982 buf.extend(iter);
17989 fn from_iter<I: IntoIterator<Item = Cow<'a, str>>>(iter: I) -> String {
17990 let mut iterator = iter.into_iter();
18008 fn extend<I: IntoIterator<Item = char>>(&mut self, iter: I) {
18009 let iterator = iter.into_iter();
18028 fn extend<I: IntoIterator<Item = &'a char>>(&mut self, iter: I) {
18029 self.extend(iter.into_iter().cloned());
18045 fn extend<I: IntoIterator<Item = &'a str>>(&mut self, iter: I) {
18046 iter.into_iter().for_each(move |s| self.push_str(s));
18057 fn extend<I: IntoIterator<Item = Box<str>>>(&mut self, iter: I) {
18058 iter.into_iter().for_each(move |s| self.push_str(&s));
18064 fn extend<I: IntoIterator<Item = String>>(&mut self, iter: I) {
18065 iter.into_iter().for_each(move |s| self.push_str(&s));
18076 fn extend<I: IntoIterator<Item = Cow<'a, str>>>(&mut self, iter: I) {
18077 iter.into_iter().for_each(move |s| self.push_str(&s));
18716 iter: Chars<'a>,
18760 self.iter.as_str()
18785 self.iter.next()
18789 self.iter.size_hint()
18802 self.iter.next_back()
19706 //! for gadget_weak in gadget_owner.gadgets.borrow().iter() {
19753 use core::iter;
20803 unsafe fn from_iter_exact(iter: impl iter::Iterator<Item = T>, len: usize) -> Rc<[T]> {
20836 for (i, item) in iter.enumerate() {
20857 unsafe { Self::from_iter_exact(v.iter().cloned(), v.len()) }
21341 impl<T> iter::FromIterator<T> for Rc<[T]> {
21380 fn from_iter<I: iter::IntoIterator<Item = T>>(iter: I) -> Self {
21381 ToRcSlice::to_rc_slice(iter.into_iter())
21396 impl<T, I: iter::TrustedLen<Item = T>> ToRcSlice<T> for I {
22039 //! * [`.iter`] and [`.iter_mut`] are the explicit methods to return the default
22045 //! [`.iter`]: slice::iter
22165 for (i, b) in s.iter().enumerate().take(slots.len()) {
22371 $slice.iter().map($f).enumerate().map(|(i, k)| (k, i as $t)).collect();
22703 let size = slice.iter().map(|slice| slice.borrow().len()).sum();
22717 let mut iter = slice.iter();
22718 let first = match iter.next() {
22722 let size = slice.iter().map(|v| v.borrow().len()).sum::<usize>() + slice.len() - 1;
22726 for v in iter {
22739 let mut iter = slice.iter();
22740 let first = match iter.next() {
22745 slice.iter().map(|v| v.borrow().len()).sum::<usize>() + sep.len() * (slice.len() - 1);
22749 for v in iter {
23285 use core::iter;
24455 unsafe fn from_iter_exact(iter: impl iter::Iterator<Item = T>, len: usize) -> Arc<[T]> {
24488 for (i, item) in iter.enumerate() {
24509 unsafe { Self::from_iter_exact(v.iter().cloned(), v.len()) }
25682 impl<T> iter::FromIterator<T> for Arc<[T]> {
25721 fn from_iter<I: iter::IntoIterator<Item = T>>(iter: I) -> Self {
25722 ToArcSlice::to_arc_slice(iter.into_iter())
25737 impl<T, I: iter::TrustedLen<Item = T>> ToArcSlice<T> for I {
26962 use core::iter::{FromIterator, FusedIterator};
26998 /// This `struct` is created by [`LinkedList::iter()`]. See its
27361 /// let mut iter = list1.iter();
27362 /// assert_eq!(iter.next(), Some(&'a'));
27363 /// assert_eq!(iter.next(), Some(&'b'));
27364 /// assert_eq!(iter.next(), Some(&'c'));
27365 /// assert!(iter.next().is_none());
27423 /// let mut iter = list.iter();
27424 /// assert_eq!(iter.next(), Some(&0));
27425 /// assert_eq!(iter.next(), Some(&1));
27426 /// assert_eq!(iter.next(), Some(&2));
27427 /// assert_eq!(iter.next(), None);
27431 pub fn iter(&self) -> Iter<'_, T> {
27452 /// let mut iter = list.iter();
27453 /// assert_eq!(iter.next(), Some(&10));
27454 /// assert_eq!(iter.next(), Some(&11));
27455 /// assert_eq!(iter.next(), Some(&12));
27456 /// assert_eq!(iter.next(), None);
27596 self.iter().any(|e| e == x)
27815 let mut iter = self.iter_mut();
27820 iter.next();
27822 iter.head
27825 let mut iter = self.iter_mut();
27827 iter.next_back();
27829 iter.tail
28573 fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
28575 list.extend(iter);
28598 self.iter()
28614 fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
28615 <Self as SpecExtend<I>>::spec_extend(self, iter);
28625 default fn spec_extend(&mut self, iter: I) {
28626 iter.into_iter().for_each(move |elt| self.push_back(elt));
28638 fn extend<I: IntoIterator<Item = &'a T>>(&mut self, iter: I) {
28639 self.extend(iter.into_iter().cloned());
28651 self.len() == other.len() && self.iter().eq(other)
28655 self.len() != other.len() || self.iter().ne(other)
28665 self.iter().partial_cmp(other)
28673 self.iter().cmp(other)
28680 self.iter().cloned().collect()
28684 let mut iter_other = other.iter();
28765 v.iter().cloned().collect()
28919 assert_eq!(a, &*n.iter().collect::<Vec<_>>());
28951 assert_eq!(v1.iter().len(), 3);
28952 assert_eq!(v1.iter().collect::<Vec<_>>().len(), 3);
29137 assert_eq!(m.iter().cloned().collect::<Vec<_>>(), &[7, 1, 8, 2, 3, 4, 5, 6]);
29143 assert_eq!(m.iter().cloned().collect::<Vec<_>>(), &[10, 7, 1, 8, 2, 3, 4, 5, 6, 9]);
29157 assert_eq!(m.iter().cloned().collect::<Vec<_>>(), &[1, 8, 2, 3, 4, 5, 6]);
29167 m.iter().cloned().collect::<Vec<_>>(),
29185 assert_eq!(m.iter().cloned().collect::<Vec<_>>(), &[200, 201, 202, 203, 1, 100, 101]);
29189 use core::iter::FusedIterator;
29209 let iter = MergeIter(MergeIterInner::new(left, right));
29212 self.bulk_push(iter, length)
29218 pub fn bulk_push<I>(&mut self, iter: I, length: &mut usize)
29224 for (key, value) in iter {
29728 for (offset, k) in unsafe { keys.get_unchecked(start_index..) }.iter().enumerate() {
29797 use core::iter::{FromIterator, FusedIterator};
30067 /// This `struct` is created by the [`iter`] method on [`BTreeMap`]. See its
30070 /// [`iter`]: BTreeMap::iter
30112 pub(super) fn iter(&self) -> Iter<'_, K, V> {
30121 f.debug_list().entries(self.iter()).finish()
30183 f.debug_list().entries(self.inner.iter().map(|(_, val)| val)).finish()
30201 f.debug_list().entries(self.inner.iter().map(|(key, _)| key)).finish()
30219 f.debug_list().entries(self.inner.iter().map(|(_, val)| val)).finish()
30438 /// assert!(map.iter().all(|(k, _v)| *k > key));
30521 /// assert!(map.iter().all(|(k, _v)| *k < key));
30865 /// .iter()
31083 self.iter()
31211 pub(super) fn iter(&self) -> Iter<'_, K, V> {
31212 Iter { range: self.range.iter(), length: self.length }
31698 pub(super) fn iter(&self) -> Range<'_, K, V> {
31721 fn from_iter<T: IntoIterator<Item = (K, V)>>(iter: T) -> BTreeMap<K, V> {
31723 map.extend(iter);
31731 fn extend<T: IntoIterator<Item = (K, V)>>(&mut self, iter: T) {
31732 iter.into_iter().for_each(move |(k, v)| {
31745 fn extend<I: IntoIterator<Item = (&'a K, &'a V)>>(&mut self, iter: I) {
31746 self.extend(iter.into_iter().map(|(&key, &value)| (key, value)));
31775 self.len() == other.len() && self.iter().zip(other).all(|(a, b)| a == b)
31786 self.iter().partial_cmp(other.iter())
31794 self.iter().cmp(other.iter())
31801 f.debug_map().entries(self.iter()).finish()
31839 /// for (key, value) in map.iter() {
31843 /// let (first_key, first_value) = map.iter().next().unwrap();
31847 pub fn iter(&self) -> Iter<'_, K, V> {
31913 Keys { inner: self.iter() }
31934 Values { inner: self.iter() }
32174 use core::iter::{FromIterator, FusedIterator, Peekable};
32248 /// This `struct` is created by the [`iter`] method on [`BTreeSet`].
32251 /// [`iter`]: BTreeSet::iter
32254 iter: Keys<'a, T, ()>,
32260 f.debug_tuple("Iter").field(&self.iter.clone()).finish()
32273 iter: super::map::IntoIter<T, ()>,
32285 iter: super::map::Range<'a, T, ()>,
32443 Range { iter: self.map.range(range) }
32475 return Difference { inner: DifferenceInner::Iterate(self.iter()) };
32481 return Difference { inner: DifferenceInner::Iterate(self.iter()) };
32485 (Greater, _) | (_, Less) => DifferenceInner::Iterate(self.iter()),
32487 let mut self_iter = self.iter();
32492 let mut self_iter = self.iter();
32497 DifferenceInner::Search { self_iter: self.iter(), other_set: other }
32500 self_iter: self.iter(),
32501 other_iter: other.iter().peekable(),
32532 SymmetricDifference(MergeIterInner::new(self.iter(), other.iter()))
32578 IntersectionInner::Search { small_iter: self.iter(), large_set: other }
32581 IntersectionInner::Search { small_iter: other.iter(), large_set: self }
32583 _ => IntersectionInner::Stitch { a: self.iter(), b: other.iter() },
32611 Union(MergeIterInner::new(self.iter(), other.iter()))
32642 /// let set: BTreeSet<_> = [1, 2, 3].iter().cloned().collect();
32666 /// let set: BTreeSet<_> = [1, 2, 3].iter().cloned().collect();
32687 /// let a: BTreeSet<_> = [1, 2, 3].iter().cloned().collect();
32712 /// let sup: BTreeSet<_> = [1, 2, 3].iter().cloned().collect();
32743 let mut self_iter = self.iter();
32765 let mut other_iter = other.iter();
32788 /// let sub: BTreeSet<_> = [1, 2].iter().cloned().collect();
33000 /// let mut set: BTreeSet<_> = [1, 2, 3].iter().cloned().collect();
33023 /// let mut set: BTreeSet<i32> = xs.iter().cloned().collect();
33026 /// assert!(set.iter().eq([2, 4, 6].iter()));
33153 /// let set: BTreeSet<usize> = [1, 2, 3].iter().cloned().collect();
33154 /// let mut set_iter = set.iter();
33166 /// let set: BTreeSet<usize> = [3, 1, 2].iter().cloned().collect();
33167 /// let mut set_iter = set.iter();
33174 pub fn iter(&self) -> Iter<'_, T> {
33175 Iter { iter: self.map.keys() }
33218 fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> BTreeSet<T> {
33220 set.extend(iter);
33237 /// let set: BTreeSet<usize> = [1, 2, 3, 4].iter().cloned().collect();
33243 IntoIter { iter: self.map.into_iter() }
33253 self.iter()
33313 fn extend<Iter: IntoIterator<Item = T>>(&mut self, iter: Iter) {
33314 iter.into_iter().for_each(move |elem| {
33327 fn extend<I: IntoIterator<Item = &'a T>>(&mut self, iter: I) {
33328 self.extend(iter.into_iter().cloned());
33440 f.debug_set().entries(self.iter()).finish()
33447 Iter { iter: self.iter.clone() }
33455 self.iter.next()
33459 self.iter.size_hint()
33477 self.iter.next_back()
33483 self.iter.len()
33495 self.iter.next().map(|(k, _)| k)
33499 self.iter.size_hint()
33505 self.iter.next_back().map(|(k, _)| k)
33511 self.iter.len()
33521 Range { iter: self.iter.clone() }
33530 self.iter.next().map(|(k, _)| k)
33549 self.iter.next_back().map(|(k, _)| k)
33568 DifferenceInner::Iterate(iter) => DifferenceInner::Iterate(iter.clone()),
33600 DifferenceInner::Iterate(iter) => iter.next(),
33610 DifferenceInner::Iterate(iter) => (iter.len(), 0),
34292 use std::iter::FromIterator;
34315 assert_eq!(a.iter().min(), None);
34316 assert_eq!(a.iter().max(), None);
34329 assert_eq!(a.iter().min(), Some(&1));
34330 assert_eq!(a.iter().max(), Some(&2));
34402 let x: BTreeSet<i32> = [3, 4].iter().copied().collect();
34403 let y: BTreeSet<i32> = [1, 2, 3].iter().copied().collect();
34404 let mut iter = x.intersection(&y);
34405 assert_eq!(iter.size_hint(), (1, Some(1)));
34406 assert_eq!(iter.next(), Some(&3));
34407 assert_eq!(iter.size_hint(), (0, Some(0)));
34408 assert_eq!(iter.next(), None);
34410 iter = y.intersection(&y);
34411 assert_eq!(iter.size_hint(), (0, Some(3)));
34412 assert_eq!(iter.next(), Some(&1));
34413 assert_eq!(iter.size_hint(), (0, Some(2)));
34454 let s246: BTreeSet<i32> = [2, 4, 6].iter().copied().collect();
34456 let mut iter = s246.difference(&s23456);
34457 assert_eq!(iter.size_hint(), (0, Some(3)));
34458 assert_eq!(iter.next(), None);
34461 iter = s246.difference(&s12345);
34462 assert_eq!(iter.size_hint(), (0, Some(3)));
34463 assert_eq!(iter.next(), Some(&6));
34464 assert_eq!(iter.size_hint(), (0, Some(0)));
34465 assert_eq!(iter.next(), None);
34468 iter = s246.difference(&s34567);
34469 assert_eq!(iter.size_hint(), (0, Some(3)));
34470 assert_eq!(iter.next(), Some(&2));
34471 assert_eq!(iter.size_hint(), (0, Some(2)));
34472 assert_eq!(iter.next(), None);
34475 iter = s246.difference(&s1);
34476 assert_eq!(iter.size_hint(), (3, Some(3)));
34479 iter = s246.difference(&s2);
34480 assert_eq!(iter.size_hint(), (2, Some(2)));
34481 assert_eq!(iter.next(), Some(&4));
34482 assert_eq!(iter.size_hint(), (1, Some(1)));
34485 iter = s246.difference(&s23);
34486 assert_eq!(iter.size_hint(), (1, Some(3)));
34487 assert_eq!(iter.next(), Some(&4));
34488 assert_eq!(iter.size_hint(), (1, Some(1)));
34491 iter = s246.difference(&s4);
34492 assert_eq!(iter.size_hint(), (2, Some(3)));
34493 assert_eq!(iter.next(), Some(&2));
34494 assert_eq!(iter.size_hint(), (1, Some(2)));
34495 assert_eq!(iter.next(), Some(&6));
34496 assert_eq!(iter.size_hint(), (0, Some(0)));
34497 assert_eq!(iter.next(), None);
34500 iter = s246.difference(&s56);
34501 assert_eq!(iter.size_hint(), (1, Some(3)));
34502 assert_eq!(iter.next(), Some(&2));
34503 assert_eq!(iter.size_hint(), (0, Some(2)));
34506 iter = s246.difference(&s6);
34507 assert_eq!(iter.size_hint(), (2, Some(2)));
34508 assert_eq!(iter.next(), Some(&2));
34509 assert_eq!(iter.size_hint(), (1, Some(1)));
34512 iter = s246.difference(&s7);
34513 assert_eq!(iter.size_hint(), (3, Some(3)));
34530 let x: BTreeSet<i32> = [2, 4].iter().copied().collect();
34531 let y: BTreeSet<i32> = [1, 2, 3].iter().copied().collect();
34532 let mut iter = x.symmetric_difference(&y);
34533 assert_eq!(iter.size_hint(), (0, Some(5)));
34534 assert_eq!(iter.next(), Some(&1));
34535 assert_eq!(iter.size_hint(), (0, Some(4)));
34536 assert_eq!(iter.next(), Some(&3));
34537 assert_eq!(iter.size_hint(), (0, Some(1)));
34558 let x: BTreeSet<i32> = [2, 4].iter().copied().collect();
34559 let y: BTreeSet<i32> = [1, 2, 3].iter().copied().collect();
34560 let mut iter = x.union(&y);
34561 assert_eq!(iter.size_hint(), (3, Some(5)));
34562 assert_eq!(iter.next(), Some(&1));
34563 assert_eq!(iter.size_hint(), (2, Some(4)));
34564 assert_eq!(iter.next(), Some(&2));
34565 assert_eq!(iter.size_hint(), (1, Some(2)));
34571 let one = [1].iter().collect::<BTreeSet<_>>();
34572 let two = [2].iter().collect::<BTreeSet<_>>();
34580 let set_a = a.iter().collect::<BTreeSet<_>>();
34581 let set_b = b.iter().collect::<BTreeSet<_>>();
34617 let mut set: BTreeSet<i32> = xs.iter().cloned().collect();
34627 let mut x: BTreeSet<_> = [1].iter().copied().collect();
34628 let mut y: BTreeSet<_> = [1].iter().copied().collect();
34701 let mut z = x.iter().zip(&y);
34712 let set: BTreeSet<_> = xs.iter().cloned().collect();
34793 let mut it = s.iter();
34805 assert_eq!(s.iter().next(), None);
34813 fn iter<'a, 'new>(v: Iter<'a, &'static str>) -> Iter<'a, &'new str> {
34831 fn iter<T: Sync>(v: &BTreeSet<T>) -> impl Sync + '_ {
34832 v.iter()
34870 fn iter<T: Send + Sync>(v: &BTreeSet<T>) -> impl Send + '_ {
34871 v.iter()
34909 set.iter();
34915 format!("{:?}", set.iter());
34994 let right = set.split_off(&(data.iter().max().unwrap() + 1));
35006 let right = set.split_off(data.iter().min().unwrap());
35034 for factor in [2, 3, 7].iter() {
35570 use std::iter::{self, FromIterator};
35593 fn test_all_refs<'a, T: 'a>(dummy: &mut T, iter: impl Iterator<Item = &'a mut T>) {
35595 let mut refs: Vec<&mut T> = iter.collect();
35678 let iter = mem::take(self).into_iter();
35680 root.bulk_push(iter, &mut self.length);
35900 fn test<T>(size: usize, mut iter: T)
35905 assert_eq!(iter.size_hint(), (size - i, Some(size - i)));
35906 assert_eq!(iter.next().unwrap(), (i, i));
35908 assert_eq!(iter.size_hint(), (0, Some(0)));
35909 assert_eq!(iter.next(), None);
35911 test(size, map.iter().map(|(&k, &v)| (k, v)));
35923 fn test<T>(size: usize, mut iter: T)
35928 assert_eq!(iter.size_hint(), (size - i, Some(size - i)));
35929 assert_eq!(iter.next().unwrap(), (size - i - 1, size - i - 1));
35931 assert_eq!(iter.size_hint(), (0, Some(0)));
35932 assert_eq!(iter.next(), None);
35934 test(size, map.iter().rev().map(|(&k, &v)| (k, v)));
36071 fn test<T>(size: usize, mut iter: T)
36076 assert_eq!(iter.size_hint(), (size - i * 2, Some(size - i * 2)));
36077 assert_eq!(iter.next().unwrap(), (i, i));
36078 assert_eq!(iter.next_back().unwrap(), (size - i - 1, size - i - 1));
36081 assert_eq!(iter.size_hint(), (size * 3 / 4 - i, Some(size * 3 / 4 - i)));
36082 assert_eq!(iter.next().unwrap(), (i, i));
36084 assert_eq!(iter.size_hint(), (0, Some(0)));
36085 assert_eq!(iter.next(), None);
36087 test(size, map.iter().map(|(&k, &v)| (k, v)));
36095 assert_eq!(a.iter().min(), None);
36096 assert_eq!(a.iter().max(), None);
36111 assert_eq!(a.iter().min(), Some((&1, &42)));
36112 assert_eq!(a.iter().max(), Some((&2, &24)));
36419 let mut iter = map.range::<str, _>((Included("b"), Excluded("d")));
36420 assert_eq!(iter.next(), Some((&"baboon".to_string(), &2)));
36421 assert_eq!(iter.next(), Some((&"coyote".to_string(), &3)));
36422 assert_eq!(iter.next(), None);
36495 assert!(map.drain_filter(|_, _| false).eq(iter::empty()));
36519 .eq(iter::empty())
36847 let mut map: BTreeMap<_, _> = xs.iter().cloned().collect();
36922 assert_eq!(m.iter().count(), 1);
36932 assert_eq!(m.iter().count(), 1);
37189 fn iter<T: Sync>(v: &BTreeMap<T, T>) -> impl Sync + '_ {
37190 v.iter()
37258 fn iter<T: Send + Sync>(v: &BTreeMap<T, T>) -> impl Send + '_ {
37259 v.iter()
37311 map.iter();
37327 format!("{:?}", map.iter());
37548 let right = map.split_off(&(data.iter().max().unwrap().0 + 1));
37562 let right = map.split_off(&data.iter().min().unwrap().0);
37609 let mut map = BTreeMap::from_iter(data.iter().copied());
37611 let small_keys = data.iter().take(len / 2).map(|kv| kv.0);
37612 let large_keys = data.iter().skip(len / 2).map(|kv| kv.0);
37826 use core::iter::FusedIterator;
40003 fn spec_extend(&mut self, iter: I);
40006 use core::iter::{FusedIterator, TrustedLen, TrustedRandomAccess};
40111 use core::iter::FusedIterator;
40127 pub(crate) iter: Iter<'a, T>,
40137 .field(&self.iter)
40214 self.iter.next().map(|elt| unsafe { ptr::read(elt) })
40219 self.iter.size_hint()
40227 self.iter.next_back().map(|elt| unsafe { ptr::read(elt) })
40370 use core::iter::{repeat_with, FromIterator};
40400 pub use self::iter::Iter;
40402 mod iter;
40454 self.iter().cloned().collect()
40460 let mut iter = PairSlices::from(self, other);
40461 while let Some((dst, src)) = iter.next() {
40465 if iter.has_remainder() {
40466 for remainder in iter.remainder() {
40467 self.extend(remainder.iter().cloned());
41031 /// output.extend(data.iter().map(|&val| {
41069 /// output.extend(data.iter().map(|&val| {
41276 /// let c: Vec<&i32> = buf.iter().collect();
41280 pub fn iter(&self) -> Iter<'_, T> {
41579 iter: Iter {
42941 /// assert!(deque.iter().take(i).all(|&x| x < 5));
42942 /// assert!(deque.iter().skip(i).all(|&x| !(x < 5)));
43054 self.iter().partial_cmp(other.iter())
43062 self.iter().cmp(other.iter())
43076 self.iter().for_each(|elem| elem.hash(state));
43100 fn from_iter<T: IntoIterator<Item = A>>(iter: T) -> VecDeque<A> {
43101 let iterator = iter.into_iter();
43127 self.iter()
43143 fn extend<T: IntoIterator<Item = A>>(&mut self, iter: T) {
43146 // for item in iter.into_iter() {
43149 let mut iter = iter.into_iter();
43150 while let Some(element) = iter.next() {
43152 let (lower, _) = iter.size_hint();
43177 fn extend<I: IntoIterator<Item = &'a T>>(&mut self, iter: I) {
43178 self.extend(iter.into_iter().cloned());
43282 use core::iter::{FusedIterator, TrustedLen, TrustedRandomAccess};
43289 /// This `struct` is created by the [`iter`] method on [`super::VecDeque`]. See its
43292 /// [`iter`]: super::VecDeque::iter
43341 accum = front.iter().fold(accum, &mut f);
43342 back.iter().fold(accum, &mut f)
43351 let (mut iter, final_res);
43354 iter = self.ring[self.tail..self.head].iter();
43355 final_res = iter.try_fold(init, &mut f);
43359 let mut back_iter = back.iter();
43363 iter = front[..self.head].iter();
43364 final_res = iter.try_fold(res?, &mut f);
43366 self.tail = self.head - iter.len();
43415 accum = back.iter().rfold(accum, &mut f);
43416 front.iter().rfold(accum, &mut f)
43425 let (mut iter, final_res);
43428 iter = self.ring[self.tail..self.head].iter();
43429 final_res = iter.try_rfold(init, &mut f);
43433 let mut front_iter = front[..self.head].iter();
43436 iter = back.iter();
43437 final_res = iter.try_rfold(res?, &mut f);
43439 self.head = self.tail + iter.len();
43468 b.iter(|| {
43481 b.iter(|| {
43495 b.iter(|| {
43509 b.iter(|| {
43699 let collected: Vec<_> = dq.iter().copied().collect();
44081 use core::iter;
44096 for &v in iter::once(&24).chain(bytes) {
44119 use core::iter::{FusedIterator, TrustedLen, TrustedRandomAccess};
44414 use core::iter::{FromIterator, FusedIterator, InPlaceIterable, SourceIter, TrustedLen};
44605 f.debug_list().entries(self.iter()).finish()
45083 /// for x in heap.iter() {
45088 pub fn iter(&self) -> Iter<'_, T> {
45089 Iter { iter: self.data.iter() }
45356 Drain { iter: self.data.drain(..) }
45454 /// This `struct` is created by [`BinaryHeap::iter()`]. See its
45457 /// [`iter`]: BinaryHeap::iter
45460 iter: slice::Iter<'a, T>,
45466 f.debug_tuple("Iter").field(&self.iter.as_slice()).finish()
45474 Iter { iter: self.iter.clone() }
45484 self.iter.next()
45489 self.iter.size_hint()
45494 self.iter.last()
45502 self.iter.next_back()
45509 self.iter.is_empty()
45525 iter: vec::IntoIter<T>,
45531 f.debug_tuple("IntoIter").field(&self.iter.as_slice()).finish()
45541 self.iter.next()
45546 self.iter.size_hint()
45554 self.iter.next_back()
45561 self.iter.is_empty()
45585 &mut self.iter
45629 iter: vec::Drain<'a, T>,
45638 self.iter.next()
45643 self.iter.size_hint()
45651 self.iter.next_back()
45658 self.iter.is_empty()
45747 fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> BinaryHeap<T> {
45748 BinaryHeap::from(iter.into_iter().collect::<Vec<_>>())
45776 IntoIter { iter: self.data.into_iter() }
45786 self.iter()
45793 fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
45794 <Self as SpecExtend<I>>::spec_extend(self, iter);
45809 default fn spec_extend(&mut self, iter: I) {
45810 self.extend_desugared(iter.into_iter());
45821 fn extend_desugared<I: IntoIterator<Item = T>>(&mut self, iter: I) {
45822 let iterator = iter.into_iter();
45833 fn extend<I: IntoIterator<Item = &'a T>>(&mut self, iter: I) {
45834 self.extend(iter.into_iter().cloned());
45851 use core::iter::{FusedIterator, InPlaceIterable, SourceIter, TrustedLen, TrustedRandomAccess};
45866 /// let iter: std::vec::IntoIter<_> = v.into_iter();
46138 use core::iter::TrustedLen;
46146 fn spec_extend(&mut self, iter: I);
46153 default fn spec_extend(&mut self, iter: I) {
46154 self.extend_desugared(iter)
46284 use core::iter::{FusedIterator, TrustedLen};
46300 /// let iter: std::vec::Drain<_> = v.drain(..);
46313 pub(super) iter: slice::Iter<'a, T>,
46320 f.debug_tuple("Drain").field(&self.iter.as_slice()).finish()
46338 self.iter.as_slice()
46367 self.iter.next().map(|elt| unsafe { ptr::read(elt as *const _) })
46371 self.iter.size_hint()
46379 self.iter.next_back().map(|elt| unsafe { ptr::read(elt as *const _) })
46428 self.iter.is_empty()
46437 use core::iter::TrustedLen;
46446 fn from_iter(iter: I) -> Self;
46594 fn from_iter(iter: I) -> Self;
46664 use core::iter::{InPlaceIterable, SourceIter, TrustedRandomAccess};
46869 use core::iter::{self, FromIterator};
46955 /// vec.extend([1, 2, 3].iter().copied());
47641 /// output.extend(data.iter().map(|&val| {
47683 /// output.extend(data.iter().map(|&val| {
47706 /// vec.extend([1, 2, 3].iter().cloned());
47734 /// vec.extend([1, 2, 3].iter().cloned());
47767 /// vec.extend([1, 2, 3].iter().cloned());
48208 /// let mut iter = keep.iter();
48209 /// vec.retain(|_| *iter.next().unwrap());
48562 iter: range_slice.iter(),
48825 /// let sum = init.iter().copied().sum::<u32>();
48927 self.spec_extend(other.iter())
49085 iter::zip(to_clone, spare)
49211 fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Vec<T> {
49212 <Self as SpecFromIter<T, I::IntoIter>>::from_iter(iter.into_iter())
49264 self.iter()
49281 fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
49282 <Self as SpecExtend<T, I::IntoIter>>::spec_extend(self, iter.into_iter())
49350 /// let u: Vec<_> = v.splice(..2, new.iter().cloned()).collect();
49432 fn extend<I: IntoIterator<Item = &'a T>>(&mut self, iter: I) {
49433 self.spec_extend(iter.into_iter())
49751 /// let iter: std::vec::DrainFilter<_, _> = v.drain_filter(|x| *x % 2 == 0);
49878 use core::iter::FromIterator;
49971 /// let iter: std::vec::Splice<_> = v.splice(1.., new.iter().cloned());
50167 b.iter(|| {
50312 use core::iter::{FromIterator, FusedIterator, Iterator};
51742 fn from_iter<T: IntoIterator<Item = I>>(iter: T) -> Self {
51743 iter.into_iter().collect::<Vec<_>>().into_boxed_slice()
52079 let iter = 0..100;
52080 let boxed: Box<[u32]> = iter.collect();