Lines Matching refs:next
1642 while let Some(elt) = map.iter().map(|(&i, _)| i).next() {
1713 while let Some(elt) = map.iter().map(|(&i, _)| i).next() {
1784 while let Some(elt) = map.iter().map(|(&i, _)| i).next() {
1910 while let Some(elt) = set.iter().copied().next() {
1981 while let Some(elt) = set.iter().copied().next() {
2706 assert_eq!(n.iter().next(), None);
2710 assert_eq!(it.next().unwrap(), &4);
2712 assert_eq!(it.next(), None);
2722 it.next();
2724 assert_eq!(it.next(), jt.next());
2726 assert_eq!(it.next(), jt.next());
2732 assert_eq!(n.iter().next(), None);
2738 assert_eq!(it.next().unwrap(), &6);
2744 assert_eq!(it.next(), None);
2754 assert_eq!(n.iter().rev().next(), None);
2758 assert_eq!(it.next().unwrap(), &4);
2760 assert_eq!(it.next(), None);
2773 assert!(n.iter_mut().next().is_none());
2778 assert!(it.next().is_some());
2779 assert!(it.next().is_some());
2781 assert!(it.next().is_none());
2793 assert_eq!(*it.next().unwrap(), 6);
2799 assert!(it.next().is_none());
2809 assert!(n.iter_mut().rev().next().is_none());
2812 assert!(it.next().is_some());
2813 assert!(it.next().is_none());
2957 assert_eq!(iter.next(), None);
2959 assert_eq!(iter.next(), None);
2976 while let Some(_) = iter.next() {
2981 assert_eq!(iter.next(), None);
3004 assert_eq!(iter.next(), None);
3023 while let Some(_) = iter.next() {
3028 assert_eq!(iter.next(), None);
3458 // `(_, Some(exact_len))` but where `.next()` drops before the last iteration.
3484 fn next(&mut self) -> Option<Self::Item> {
3485 self.0.next().flatten()
4627 if Some(c) != s.chars().next() {
4639 if Some(c) != s.chars().rev().next() {
4649 it.next();
4657 it.next();
4769 it.next();
5251 match if !rev { searcher.next() } else { searcher.next_back() } {
7427 let _ = into_iter.next().unwrap();
7429 let _ = into_iter.next().unwrap();
7430 let _ = into_iter.next().unwrap();
7441 assert_eq!(into_iter.next().unwrap(), 'x');
7466 assert_eq!(it.next(), Some(1));
7469 assert_eq!(it.next(), Some(3));
7471 assert_eq!(it.next(), Some(2));
7473 assert_eq!(it.next(), None);
7515 iter.next();
7516 iter.next();
7665 it.next().unwrap();
7693 assert_eq!(iter.next(), None);
7695 assert_eq!(iter.next(), None);
7710 while let Some(_) = iter.next() {
7715 assert_eq!(iter.next(), None);
7737 assert_eq!(iter.next(), None);
7755 while let Some(_) = iter.next() {
7760 assert_eq!(iter.next(), None);
8192 /// Useful to cover both the `next` and `drop` paths of an iterator.
8194 i.next().unwrap();
9211 // `(_, Some(exact_len))` but where `.next()` drops before the last iteration.
9237 fn next(&mut self) -> Option<Self::Item> {
9238 self.0.next().flatten()
9974 assert_eq!(it.next().unwrap(), &1);
9976 assert_eq!(it.next().unwrap(), &2);
9978 assert_eq!(it.next().unwrap(), &5);
9980 assert_eq!(it.next().unwrap(), &10);
9982 assert_eq!(it.next().unwrap(), &11);
9984 assert!(it.next().is_none());
9999 iter.next();
10008 iter.next();
10016 it.next();
10018 assert_eq!(it.next(), jt.next());
10019 assert_eq!(it.next(), jt.next());
10020 assert_eq!(it.next(), jt.next());
10239 assert!(xs.rsplitn(0, |x| *x % 2 == 0).next().is_none());
10251 assert!(v.windows(6).next().is_none());
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);
11169 assert_eq!(iter.next(), Some(&[1, 1, 1][..]));
11171 assert_eq!(iter.next(), Some(&[3, 3][..]));
11173 assert_eq!(iter.next(), Some(&[2, 2, 2][..]));
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);
11198 assert_eq!(iter.next(), Some(&mut [1, 1, 1][..]));
11200 assert_eq!(iter.next(), Some(&mut [3, 3][..]));
11202 assert_eq!(iter.next(), Some(&mut [2, 2, 2][..]));
11427 // (Vec grows to next power of two)
11465 assert_eq!(d.iter().next(), None);
11487 match it.next() {
11500 assert_eq!(d.iter().rev().next(), None);
11520 assert!(d.iter_mut().rev().next().is_none());
11534 assert!(d.iter_mut().next().is_none());
11547 assert_eq!(*it.next().unwrap(), 0);
11548 assert_eq!(*it.next().unwrap(), 1);
11549 assert_eq!(*it.next().unwrap(), 2);
11550 assert!(it.next().is_none());
11557 assert!(d.iter_mut().rev().next().is_none());
11570 assert_eq!(*it.next().unwrap(), 0);
11571 assert_eq!(*it.next().unwrap(), 1);
11572 assert_eq!(*it.next().unwrap(), 2);
11573 assert!(it.next().is_none());
11585 assert_eq!(iter.next(), None);
11626 assert_eq!(it.next(), Some(8));
11630 assert_eq!(it.next(), Some(7));
11645 assert_eq!(iter.next(), None);
11690 assert_eq!(it.next(), Some(8));
11694 assert_eq!(it.next(), Some(7));
12401 // and also rounds the number to next power of 2 so this is the
12502 // and also rounds the number to next power of 2 so this is the
12745 assert_eq!(iter.next(), Some(&60));
12771 assert_eq!(Some(&7), iter.next());
13329 assert_eq!(it.next(), Some(9));
13332 assert_eq!(it.next(), Some(5));
13335 assert_eq!(it.next(), None);
13372 it.next();
13396 it.next();
13520 let heap_ptr = heap.iter().next().unwrap() as *const usize;
15121 let first = match iter.next() {
15369 match iter.skip_while(|&c| Case_Ignorable(c)).next() {
16713 let (first_valid, first_broken) = if let Some(chunk) = iter.next() {
17330 let ch = self.chars().rev().next()?;
17362 let ch = match self[idx..].chars().next() {
17367 let next = idx + ch.len_utf8();
17370 ptr::copy(self.vec.as_ptr().add(next), self.vec.as_mut_ptr().add(idx), len - next);
17371 self.vec.set_len(len - (next - idx));
17481 let ch = unsafe { guard.s.get_unchecked(guard.idx..len).chars().next().unwrap() };
17496 // Point idx to the next char
17968 match iterator.next() {
17995 match iterator.next() {
18755 /// let _ = drain.next().unwrap();
18784 fn next(&mut self) -> Option<char> {
18785 self.iter.next()
22718 let first = match iter.next() {
22740 let first = match iter.next() {
22889 // run and the longer run forwards (or backwards), comparing their next unconsumed elements and
23039 // Find the next natural run, and reverse it if it's strictly descending.
23089 // Examines the stack of runs and identifies the next pair of runs to merge. More specifically,
23090 // if `Some(r)` is returned, that means `runs[r]` and `runs[r + 1]` must be merged next. If the
25840 //! referencing, and if omitted it is assumed to be "the next argument". For
25846 //! positional specifiers. The "next argument" specifier can be thought of as an
25847 //! iterator over the argument. Each time a "next argument" specifier is seen,
25912 //! Referring to an argument with the dollar syntax does not affect the "next
26024 //! // Hello {next arg ("x")} is {second of next two args (0.01) with precision
26025 //! // specified in first of next two args (5)}
26028 //! // Hello {next arg ("x")} is {arg 2 (0.01) with precision
26032 //! // Hello {next arg ("x")} is {arg "number" (0.01) with precision specified
26991 next: Option<NonNull<Node<T>>>,
27066 Node { next: None, prev: None, element }
27082 node.next = self.head;
27104 self.head = node.next;
27123 node.next = None;
27130 Some(tail) => (*tail.as_ptr()).next = node,
27150 Some(tail) => (*tail.as_ptr()).next = None,
27170 Some(prev) => unsafe { (*prev.as_ptr()).next = node.next },
27172 None => self.head = node.next,
27175 match node.next {
27176 Some(next) => unsafe { (*next.as_ptr()).prev = node.prev },
27200 existing_prev.as_mut().next = Some(splice_start);
27214 splice_end.as_mut().next = existing_next;
27249 tail.as_mut().next = None;
27285 second_part_head = split_node.as_mut().next.take();
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());
27378 tail.as_mut().next = Some(other_head);
27400 other_tail.as_mut().next = Some(head);
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);
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);
27820 iter.next();
27945 fn next(&mut self) -> Option<&'a T> {
27953 self.head = node.next;
27999 fn next(&mut self) -> Option<&'a mut T> {
28007 self.head = node.next;
28114 /// Moves the cursor to the next element of the `LinkedList`.
28128 // We had a previous element, so let's go to its next
28130 self.current = current.as_ref().next;
28167 /// Returns a reference to the next element.
28175 let next = match self.current {
28177 Some(current) => current.as_ref().next,
28179 next.map(|next| &(*next.as_ptr()).element)
28211 /// Moves the cursor to the next element of the `LinkedList`.
28225 // We had a previous element, so let's go to its next
28227 self.current = current.as_ref().next;
28264 /// Returns a reference to the next element.
28272 let next = match self.current {
28274 Some(current) => current.as_ref().next,
28276 next.map(|next| &mut (*next.as_ptr()).element)
28320 Some(node) => node.as_ref().next,
28350 /// moved to point to the next element in the `LinkedList`.
28358 self.current = unlinked_node.as_ref().next;
28368 /// The cursor is moved to point to the next element in the current `LinkedList`.
28376 self.current = unlinked_node.as_ref().next;
28380 unlinked_node.as_mut().next = None;
28403 Some(node) => node.as_ref().next,
28483 fn next(&mut self) -> Option<T> {
28486 self.it = node.as_ref().next;
28524 while let Some(item) = self.next() {
28547 fn next(&mut self) -> Option<T> {
28791 match node_ptr.next {
28792 Some(next) => {
28794 node_ptr = &*next.as_ptr();
29283 fn next(&mut self) -> Option<(K, V)> {
29422 pub fn next(&mut self) -> u32 {
30829 /// assert_eq!(Some((&5, &"b")), map.range(4..).next());
31091 fn next(&mut self) -> Option<(&'a K, &'a V)> {
31109 self.next()
31160 fn next(&mut self) -> Option<(&'a K, &'a mut V)> {
31178 self.next()
31277 fn next(&mut self) -> Option<(K, V)> {
31317 fn next(&mut self) -> Option<&'a K> {
31318 self.inner.next().map(|(k, _)| k)
31330 self.next()
31366 fn next(&mut self) -> Option<&'a V> {
31367 self.inner.next().map(|(_, v)| v)
31422 /// Contains a leaf edge preceding the next element to be returned, or the last leaf edge.
31457 fn next(&mut self) -> Option<(K, V)> {
31458 self.inner.next(&mut self.pred)
31467 /// Allow Debug implementations to predict the next element.
31473 /// Implementation of a typical `DrainFilter::next` method, given the predicate.
31474 pub(super) fn next<F>(&mut self, pred: &mut F) -> Option<(K, V)>
31514 fn next(&mut self) -> Option<(&'a K, &'a V)> {
31523 self.next()
31535 fn next(&mut self) -> Option<&'a mut V> {
31536 self.inner.next().map(|(_, v)| v)
31575 fn next(&mut self) -> Option<K> {
31576 self.inner.next().map(|(k, _)| k)
31588 self.next()
31617 fn next(&mut self) -> Option<V> {
31618 self.inner.next().map(|(_, v)| v)
31674 fn next(&mut self) -> Option<(&'a K, &'a mut V)> {
31683 self.next()
31843 /// let (first_key, first_value) = map.iter().next().unwrap();
32434 /// assert_eq!(Some(&5), set.range(4..).next());
32488 self_iter.next();
32701 self.intersection(other).next().is_none()
32726 // Same result as self.difference(other).next().is_none()
32747 self_iter.next();
32759 for next in self_iter {
32760 if !other.contains(next) {
32766 other_iter.next();
32768 let mut self_next = self_iter.next();
32770 match other_iter.next().map_or(Less, |other1| self1.cmp(other1)) {
32772 Equal => self_next = self_iter.next(),
33155 /// assert_eq!(set_iter.next(), Some(&1));
33156 /// assert_eq!(set_iter.next(), Some(&2));
33157 /// assert_eq!(set_iter.next(), Some(&3));
33158 /// assert_eq!(set_iter.next(), None);
33168 /// assert_eq!(set_iter.next(), Some(&1));
33169 /// assert_eq!(set_iter.next(), Some(&2));
33170 /// assert_eq!(set_iter.next(), Some(&3));
33171 /// assert_eq!(set_iter.next(), None);
33296 fn next(&mut self) -> Option<T> {
33299 self.inner.next(&mut mapped_pred).map(|(k, _)| k)
33454 fn next(&mut self) -> Option<&'a T> {
33455 self.iter.next()
33467 self.next()
33494 fn next(&mut self) -> Option<T> {
33495 self.iter.next().map(|(k, _)| k)
33529 fn next(&mut self) -> Option<&'a T> {
33530 self.iter.next().map(|(k, _)| k)
33538 self.next()
33577 fn next(&mut self) -> Option<&'a T> {
33580 let mut self_next = self_iter.next()?;
33585 self_next = self_iter.next()?;
33586 other_iter.next();
33589 other_iter.next();
33595 let self_next = self_iter.next()?;
33600 DifferenceInner::Iterate(iter) => iter.next(),
33616 self.next()
33633 fn next(&mut self) -> Option<&'a T> {
33651 self.next()
33678 fn next(&mut self) -> Option<&'a T> {
33681 let mut a_next = a.next()?;
33682 let mut b_next = b.next()?;
33685 Less => a_next = a.next()?,
33686 Greater => b_next = b.next()?,
33692 let small_next = small_iter.next()?;
33711 self.next()
33728 fn next(&mut self) -> Option<&'a T> {
33740 self.next()
33987 /// Given a leaf edge handle into a dying tree, returns the next leaf edge
34015 /// Given a leaf edge handle into a dying tree, returns the next leaf edge
34058 /// Moves the leaf edge handle to the next leaf edge and returns references to the
34086 /// Moves the leaf edge handle to the next leaf edge and returns references to the
34118 /// Moves the leaf edge handle to the next leaf edge and returns the key and value
34406 assert_eq!(iter.next(), Some(&3));
34408 assert_eq!(iter.next(), None);
34412 assert_eq!(iter.next(), Some(&1));
34458 assert_eq!(iter.next(), None);
34463 assert_eq!(iter.next(), Some(&6));
34465 assert_eq!(iter.next(), None);
34470 assert_eq!(iter.next(), Some(&2));
34472 assert_eq!(iter.next(), None);
34481 assert_eq!(iter.next(), Some(&4));
34487 assert_eq!(iter.next(), Some(&4));
34493 assert_eq!(iter.next(), Some(&2));
34495 assert_eq!(iter.next(), Some(&6));
34497 assert_eq!(iter.next(), None);
34502 assert_eq!(iter.next(), Some(&2));
34508 assert_eq!(iter.next(), Some(&2));
34534 assert_eq!(iter.next(), Some(&1));
34536 assert_eq!(iter.next(), Some(&3));
34562 assert_eq!(iter.next(), Some(&1));
34564 assert_eq!(iter.next(), Some(&2));
34703 assert_eq!(z.next().unwrap(), (&5, &("bar")));
34704 assert_eq!(z.next().unwrap(), (&11, &("foo")));
34705 assert!(z.next().is_none());
34794 assert_eq!(it.next(), Some(&Foo("a", 2)));
34795 assert_eq!(it.next(), None);
34805 assert_eq!(s.iter().next(), None);
34986 Vec::from_iter((0..len).map(|_| rng.next()))
35663 if let Some(mut previous) = keys.next() {
35664 for next in keys {
35665 assert!(previous < next, "{:?} >= {:?}", previous, next);
35666 previous = next;
35819 assert_eq!(map.range(..).next(), None);
35820 assert_eq!(map.range(..1).next(), None);
35821 assert_eq!(map.range(1..).next(), None);
35822 assert_eq!(map.range(1..=1).next(), None);
35823 assert_eq!(map.range(1..2).next(), None);
35883 assert_eq!(map.range(..).next(), None);
35884 assert_eq!(map.range(..1).next(), None);
35885 assert_eq!(map.range(1..).next(), None);
35886 assert_eq!(map.range(1..=1).next(), None);
35887 assert_eq!(map.range(1..2).next(), None);
35906 assert_eq!(iter.next().unwrap(), (i, i));
35909 assert_eq!(iter.next(), None);
35929 assert_eq!(iter.next().unwrap(), (size - i - 1, size - i - 1));
35932 assert_eq!(iter.next(), None);
36036 let front = it.next().unwrap();
36044 assert_eq!(it.next(), None);
36054 let front = it.next().unwrap();
36077 assert_eq!(iter.next().unwrap(), (i, i));
36082 assert_eq!(iter.next().unwrap(), (i, i));
36085 assert_eq!(iter.next(), None);
36296 assert_eq!(map.range((Included(2), Excluded(2))).next(), None);
36297 assert_eq!(map.range((Excluded(2), Included(2))).next(), None);
36400 assert_eq!(kvs.next(), None);
36401 assert_eq!(pairs.next(), None);
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);
36440 assert_eq!(kvs.next(), None);
36441 assert_eq!(pairs.next(), None);
36461 assert_eq!(kvs.next(), None);
36462 assert_eq!(pairs.next(), None);
36750 catch_unwind(AssertUnwindSafe(|| while it.next().is_some() {})).unwrap_err();
36753 let result = catch_unwind(AssertUnwindSafe(|| it.next()));
37540 Vec::from_iter((0..len).map(|_| (rng.next(), rng.next())))
37607 let mut data = Vec::from_iter((0..len).map(|_| (rng.next(), ())));
37613 let split_key = large_keys.clone().next().unwrap();
37870 /// Returns the next pair of items stemming from the pair of sources
37887 Some(Peeked::A(next)) => {
37888 a_next = Some(next);
37889 b_next = self.b.next();
37891 Some(Peeked::B(next)) => {
37892 b_next = Some(next);
37893 a_next = self.a.next();
37896 a_next = self.a.next();
37897 b_next = self.b.next();
39873 // `MIN_LEN + 1` to avoid readjust if merge happens on the next level.
39893 // `MIN_LEN + 1` to avoid readjust if merge happens on the next level.
40034 fn next(&mut self) -> Option<T> {
40198 while let Some(item) = self.next() {
40213 fn next(&mut self) -> Option<T> {
40214 self.iter.next().map(|elt| unsafe { ptr::read(elt) })
40337 fn next(&mut self) -> Option<Self::Item> {
40338 // Get next part length
40461 while let Some((dst, src)) = iter.next() {
42248 // or quasi-discontiguous, remove next to head, tail section:
43150 while let Some(element) = iter.next() {
43321 fn next(&mut self) -> Option<&'a T> {
43376 self.next()
44162 fn next(&mut self) -> Option<&'a mut T> {
44199 self.next()
44349 //! let next = State { cost: cost + edge.cost, position: edge.node };
44352 //! if next.cost < dist[next.position] {
44353 //! heap.push(next);
44355 //! dist[next.position] = next.cost;
44445 /// // We can use peek to look at the next item in the heap. In this case,
45483 fn next(&mut self) -> Option<&'a T> {
45484 self.iter.next()
45540 fn next(&mut self) -> Option<T> {
45541 self.iter.next()
45600 fn next(&mut self) -> Option<T> {
45637 fn next(&mut self) -> Option<T> {
45638 self.iter.next()
45702 fn next(&mut self) -> Option<T> {
45897 /// let _ = into_iter.next().unwrap();
45914 /// assert_eq!(into_iter.next().unwrap(), 'a');
45915 /// assert_eq!(into_iter.next().unwrap(), 'b');
45916 /// assert_eq!(into_iter.next().unwrap(), 'z');
45977 fn next(&mut self) -> Option<T> {
46333 /// let _ = drain.next().unwrap();
46366 fn next(&mut self) -> Option<T> {
46367 self.iter.next().map(|elt| unsafe { ptr::read(elt as *const _) })
46414 while let Some(item) = self.next() {
46459 let mut vector = match iterator.next() {
48209 /// vec.retain(|_| *iter.next().unwrap());
48223 // |<- processed len ->| ^- next to check
48827 /// // Fill in the next 4 elements.
48964 fn next(&mut self) -> T;
48970 fn next(&mut self) -> T {
48980 fn next(&mut self) -> T {
48990 fn next(&mut self) -> T {
49012 ptr::write(ptr, value.next());
49014 // Increment the length in every step in case next() panics
49307 while let Some(element) = iterator.next() {
49764 /// The index of the item that will be inspected by the next call to `next`.
49799 fn next(&mut self) -> Option<T> {
49988 fn next(&mut self) -> Option<Self::Item> {
49989 self.drain.next()
50053 /// Returns `true` if we filled the entire range. (`replace_with.next()` didn’t return `None`.)
50063 if let Some(new_item) = replace_with.next() {
51649 fn next(&mut self) -> Option<I::Item> {
51650 (**self).next()