std::iter::DoubleEndedIterator - Rust (original) (raw)

Trait std::iter::DoubleEndedIterator1.0.0 [−] [src]

pub trait DoubleEndedIterator: Iterator { fn next_back(&mut self) -> Option<Self::Item>;

fn [try_rfold](#method.try%5Frfold)<B, F, R>(&mut self, init: B, f: F) -> R

    where
        F: FnMut(B, Self::Item) -> R,
        R: Try<Ok = B>, { ... } fn rfold<B, F>(self, accum: B, f: F) -> B
    where
        F: FnMut(B, Self::Item) -> B, { ... } fn rfind

(&mut self, predicate: P) -> Option<Self::Item>
    where
        P: FnMut(&Self::Item) -> bool, { ... } }

An iterator able to yield elements from both ends.

Something that implements DoubleEndedIterator has one extra capability over something that implements Iterator: the ability to also takeItems from the back, as well as the front.

It is important to note that both back and forth work on the same range, and do not cross: iteration is over when they meet in the middle.

In a similar fashion to the Iterator protocol, once aDoubleEndedIterator returns None from a next_back(), calling it again may or may not ever return Some again. next() and next_back() are interchangeable for this purpose.

Basic usage:

let numbers = vec![1, 2, 3, 4, 5, 6];

let mut iter = numbers.iter();

assert_eq!(Some(&1), iter.next()); assert_eq!(Some(&6), iter.next_back()); assert_eq!(Some(&5), iter.next_back()); assert_eq!(Some(&2), iter.next()); assert_eq!(Some(&3), iter.next()); assert_eq!(Some(&4), iter.next()); assert_eq!(None, iter.next()); assert_eq!(None, iter.next_back());Run

fn [next_back](#tymethod.next%5Fback)(&mut self) -> [Option](../../std/option/enum.Option.html "enum std::option::Option")<Self::[Item](../../std/iter/trait.Iterator.html#associatedtype.Item "type std::iter::Iterator::Item")>

Removes and returns an element from the end of the iterator.

Returns None when there are no more elements.

The trait-level docs contain more details.

Basic usage:

let numbers = vec![1, 2, 3, 4, 5, 6];

let mut iter = numbers.iter();

assert_eq!(Some(&1), iter.next()); assert_eq!(Some(&6), iter.next_back()); assert_eq!(Some(&5), iter.next_back()); assert_eq!(Some(&2), iter.next()); assert_eq!(Some(&3), iter.next()); assert_eq!(Some(&4), iter.next()); assert_eq!(None, iter.next()); assert_eq!(None, iter.next_back());Run

`fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R where

F: FnMut(B, Self::Item) -> R,
R: Try<Ok = B>, `

🔬 This is a nightly-only experimental API. (iterator_try_fold #45594)

This is the reverse version of try_fold(): it takes elements starting from the back of the iterator.

Basic usage:

#![feature(iterator_try_fold)] let a = ["1", "2", "3"]; let sum = a.iter() .map(|&s| s.parse::()) .try_rfold(0, |acc, x| x.and_then(|y| Ok(acc + y))); assert_eq!(sum, Ok(6));Run

Short-circuiting:

#![feature(iterator_try_fold)] let a = ["1", "rust", "3"]; let mut it = a.iter(); let sum = it .by_ref() .map(|&s| s.parse::()) .try_rfold(0, |acc, x| x.and_then(|y| Ok(acc + y))); assert!(sum.is_err());

assert_eq!(it.next_back(), Some(&"1"));Run

`fn rfold<B, F>(self, accum: B, f: F) -> B where

F: FnMut(B, Self::Item) -> B, `

🔬 This is a nightly-only experimental API. (iter_rfold #44705)

An iterator method that reduces the iterator's elements to a single, final value, starting from the back.

This is the reverse version of fold(): it takes elements starting from the back of the iterator.

rfold() takes two arguments: an initial value, and a closure with two arguments: an 'accumulator', and an element. The closure returns the value that the accumulator should have for the next iteration.

The initial value is the value the accumulator will have on the first call.

After applying this closure to every element of the iterator, rfold()returns the accumulator.

This operation is sometimes called 'reduce' or 'inject'.

Folding is useful whenever you have a collection of something, and want to produce a single value from it.

Basic usage:

#![feature(iter_rfold)] let a = [1, 2, 3];

let sum = a.iter() .rfold(0, |acc, &x| acc + x);

assert_eq!(sum, 6);Run

This example builds a string, starting with an initial value and continuing with each element from the back until the front:

#![feature(iter_rfold)] let numbers = [1, 2, 3, 4, 5];

let zero = "0".to_string();

let result = numbers.iter().rfold(zero, |acc, &x| { format!("({} + {})", x, acc) });

assert_eq!(result, "(1 + (2 + (3 + (4 + (5 + 0)))))");Run

`fn rfind

(&mut self, predicate: P) -> Option<Self::Item> where

P: FnMut(&Self::Item) -> bool, `

🔬 This is a nightly-only experimental API. (iter_rfind #39480)

Searches for an element of an iterator from the right that satisfies a predicate.

rfind() takes a closure that returns true or false. It applies this closure to each element of the iterator, starting at the end, and if any of them return true, then rfind() returns Some(element). If they all returnfalse, it returns None.

rfind() is short-circuiting; in other words, it will stop processing as soon as the closure returns true.

Because rfind() takes a reference, and many iterators iterate over references, this leads to a possibly confusing situation where the argument is a double reference. You can see this effect in the examples below, with &&x.

Basic usage:

#![feature(iter_rfind)]

let a = [1, 2, 3];

assert_eq!(a.iter().rfind(|&&x| x == 2), Some(&2));

assert_eq!(a.iter().rfind(|&&x| x == 5), None);Run

Stopping at the first true:

#![feature(iter_rfind)]

let a = [1, 2, 3];

let mut iter = a.iter();

assert_eq!(iter.rfind(|&&x| x == 2), Some(&2));

assert_eq!(iter.next_back(), Some(&1));Run