Trait otter_api_tests::iter::IntoIterator 1.0.0[−][src]
pub trait IntoIterator { type Item; type IntoIter: Iterator; fn into_iter(self) -> Self::IntoIter; }
Expand description
Conversion into an Iterator
.
By implementing IntoIterator
for a type, you define how it will be
converted to an iterator. This is common for types which describe a
collection of some kind.
One benefit of implementing IntoIterator
is that your type will work
with Rust’s for
loop syntax.
See also: FromIterator
.
Examples
Basic usage:
let v = vec![1, 2, 3]; let mut iter = v.into_iter(); assert_eq!(Some(1), iter.next()); assert_eq!(Some(2), iter.next()); assert_eq!(Some(3), iter.next()); assert_eq!(None, iter.next());
Implementing IntoIterator
for your type:
// A sample collection, that's just a wrapper over Vec<T> #[derive(Debug)] struct MyCollection(Vec<i32>); // Let's give it some methods so we can create one and add things // to it. impl MyCollection { fn new() -> MyCollection { MyCollection(Vec::new()) } fn add(&mut self, elem: i32) { self.0.push(elem); } } // and we'll implement IntoIterator impl IntoIterator for MyCollection { type Item = i32; type IntoIter = std::vec::IntoIter<Self::Item>; fn into_iter(self) -> Self::IntoIter { self.0.into_iter() } } // Now we can make a new collection... let mut c = MyCollection::new(); // ... add some stuff to it ... c.add(0); c.add(1); c.add(2); // ... and then turn it into an Iterator: for (i, n) in c.into_iter().enumerate() { assert_eq!(i as i32, n); }
It is common to use IntoIterator
as a trait bound. This allows
the input collection type to change, so long as it is still an
iterator. Additional bounds can be specified by restricting on
Item
:
fn collect_as_strings<T>(collection: T) -> Vec<String> where T: IntoIterator, T::Item: std::fmt::Debug, { collection .into_iter() .map(|item| format!("{:?}", item)) .collect() }
Associated Types
Required methods
Creates an iterator from a value.
See the module-level documentation for more.
Examples
Basic usage:
let v = vec![1, 2, 3]; let mut iter = v.into_iter(); assert_eq!(Some(1), iter.next()); assert_eq!(Some(2), iter.next()); assert_eq!(Some(3), iter.next()); assert_eq!(None, iter.next());
Implementations on Foreign Types
Creates a consuming iterator, that is, one that moves each value out of
the array (from start to end). The array cannot be used after calling
this unless T
implements Copy
, so the whole array is copied.
Arrays have special behavior when calling .into_iter()
prior to the
2021 edition – see the array Editions section for more information.
type Item = T
Creates a consuming iterator, that is, one that moves each value out of the vector (from start to end). The vector cannot be used after calling this.
Examples
let v = vec!["a".to_string(), "b".to_string()]; for s in v.into_iter() { // s has type String, not &String println!("{}", s); }
type Item = T
Creates a consuming iterator, that is, one that moves each value out of the binary heap in arbitrary order. The binary heap cannot be used after calling this.
Examples
Basic usage:
use std::collections::BinaryHeap; let heap = BinaryHeap::from(vec![1, 2, 3, 4]); // Print 1, 2, 3, 4 in arbitrary order for x in heap.into_iter() { // x has type i32, not &i32 println!("{}", x); }
type Item = T
impl<'a> IntoIterator for &'a Utf8Sequence
impl<'a> IntoIterator for &'a Utf8Sequence
impl<T> IntoIterator for Slab<T>
impl<T> IntoIterator for Slab<T>
impl<'a, T> IntoIterator for &'a mut Slab<T>
impl<'a, T> IntoIterator for &'a mut Slab<T>
impl<'a, T> IntoIterator for &'a Slab<T>
impl<'a, T> IntoIterator for &'a Slab<T>
impl IntoIterator for WalkDir
impl IntoIterator for WalkDir
impl<I, A> IntoIterator for Box<IndexSlice<I, [A]>, Global> where
I: Idx,
impl<I, A> IntoIterator for Box<IndexSlice<I, [A]>, Global> where
I: Idx,
type Item = A
pub fn into_iter(
self
) -> <Box<IndexSlice<I, [A]>, Global> as IntoIterator>::IntoIterⓘNotable traits for Box<R, Global>
impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
impl<'a, A> IntoIterator for &'a SmallVec<A> where
A: Array,
impl<'a, A> IntoIterator for &'a SmallVec<A> where
A: Array,
impl<'a, A> IntoIterator for &'a mut SmallVec<A> where
A: Array,
impl<'a, A> IntoIterator for &'a mut SmallVec<A> where
A: Array,
impl<A> IntoIterator for SmallVec<A> where
A: Array,
impl<A> IntoIterator for SmallVec<A> where
A: Array,
type IntoIter = IntoIter<A>
type Item = <A as Array>::Item
pub fn into_iter(self) -> <SmallVec<A> as IntoIterator>::IntoIter
pub fn into_iter(self) -> IndexVecIntoIterⓘNotable traits for IndexVecIntoIter
impl Iterator for IndexVecIntoIter type Item = usize;
[src]
pub fn into_iter(self) -> IndexVecIntoIterⓘNotable traits for IndexVecIntoIter
impl Iterator for IndexVecIntoIter type Item = usize;
[src]Convert into an iterator over the indices as a sequence of usize
values
type IntoIter = IndexVecIntoIter
impl<'a, A> IntoIterator for &'a mut ArrayVec<A> where
A: Array,
impl<'a, A> IntoIterator for &'a mut ArrayVec<A> where
A: Array,
impl<'s, T> IntoIterator for SliceVec<'s, T>
impl<'s, T> IntoIterator for SliceVec<'s, T>
impl<'a, A> IntoIterator for &'a TinyVec<A> where
A: Array,
impl<'a, A> IntoIterator for &'a TinyVec<A> where
A: Array,
impl<'a, A> IntoIterator for &'a ArrayVec<A> where
A: Array,
impl<'a, A> IntoIterator for &'a ArrayVec<A> where
A: Array,
impl<A> IntoIterator for ArrayVec<A> where
A: Array,
impl<A> IntoIterator for ArrayVec<A> where
A: Array,
type Item = <A as Array>::Item
type IntoIter = ArrayVecIterator<A>
#[must_use]pub fn into_iter(self) -> <ArrayVec<A> as IntoIterator>::IntoIter
impl<A> IntoIterator for TinyVec<A> where
A: Array,
impl<A> IntoIterator for TinyVec<A> where
A: Array,
type Item = <A as Array>::Item
type IntoIter = TinyVecIterator<A>
#[must_use]pub fn into_iter(self) -> <TinyVec<A> as IntoIterator>::IntoIter
impl<'a, A> IntoIterator for &'a mut TinyVec<A> where
A: Array,
impl<'a, A> IntoIterator for &'a mut TinyVec<A> where
A: Array,
impl IntoIterator for CharRange
impl IntoIterator for CharRange
impl<'a, T> IntoIterator for &'a ThreadLocal<T> where
T: Send + Sync,
impl<'a, T> IntoIterator for &'a ThreadLocal<T> where
T: Send + Sync,
impl<'a, T> IntoIterator for &'a mut CachedThreadLocal<T> where
T: 'a + Send,
impl<'a, T> IntoIterator for &'a mut CachedThreadLocal<T> where
T: 'a + Send,
impl<T> IntoIterator for CachedThreadLocal<T> where
T: Send,
impl<T> IntoIterator for CachedThreadLocal<T> where
T: Send,
impl<'a, T> IntoIterator for &'a mut ThreadLocal<T> where
T: Send,
impl<'a, T> IntoIterator for &'a mut ThreadLocal<T> where
T: Send,
impl<T> IntoIterator for ThreadLocal<T> where
T: Send,
impl<T> IntoIterator for ThreadLocal<T> where
T: Send,
impl IntoIterator for CharRange
impl IntoIterator for CharRange
impl<T> IntoIterator for VecMap<T>
impl<T> IntoIterator for VecMap<T>
Returns an iterator visiting all key-value pairs in ascending order of
the keys, consuming the original VecMap
.
The iterator’s element type is (usize, &'r V)
.
Examples
use vec_map::VecMap; let mut map = VecMap::new(); map.insert(1, "a"); map.insert(3, "c"); map.insert(2, "b"); let vec: Vec<(usize, &str)> = map.into_iter().collect(); assert_eq!(vec, [(1, "a"), (2, "b"), (3, "c")]);
type IntoIter = IntoIter<T>
impl<'a, T> IntoIterator for &'a VecMap<T>
impl<'a, T> IntoIterator for &'a VecMap<T>
impl<'a, T> IntoIterator for &'a mut VecMap<T>
impl<'a, T> IntoIterator for &'a mut VecMap<T>
type IntoIter = ValueIterMut<'a, T>
pub fn into_iter(self) -> ValueIterMut<'a, T>ⓘNotable traits for ValueIterMut<'a, T>
impl<'a, T> Iterator for ValueIterMut<'a, T> where
T: 'a, type Item = &'a mut T;
[src]type IntoIter = ValueIterMut<'a, T>
pub fn into_iter(self) -> ValueIterMut<'a, T>ⓘNotable traits for ValueIterMut<'a, T>
impl<'a, T> Iterator for ValueIterMut<'a, T> where
T: 'a, type Item = &'a mut T;
[src]Creates a consuming iterator, that is, one that moves keys and values out of the map in arbitrary order. The map cannot be used after calling this.
For each yielded item that has None
provided for the HeaderName
,
then the associated header name is the same as that of the previously
yielded item. The first yielded item will have HeaderName
set.
Examples
Basic usage.
let mut map = HeaderMap::new(); map.insert(header::CONTENT_LENGTH, "123".parse().unwrap()); map.insert(header::CONTENT_TYPE, "json".parse().unwrap()); let mut iter = map.into_iter(); assert_eq!(iter.next(), Some((Some(header::CONTENT_LENGTH), "123".parse().unwrap()))); assert_eq!(iter.next(), Some((Some(header::CONTENT_TYPE), "json".parse().unwrap()))); assert!(iter.next().is_none());
Multiple values per key.
let mut map = HeaderMap::new(); map.append(header::CONTENT_LENGTH, "123".parse().unwrap()); map.append(header::CONTENT_LENGTH, "456".parse().unwrap()); map.append(header::CONTENT_TYPE, "json".parse().unwrap()); map.append(header::CONTENT_TYPE, "html".parse().unwrap()); map.append(header::CONTENT_TYPE, "xml".parse().unwrap()); let mut iter = map.into_iter(); assert_eq!(iter.next(), Some((Some(header::CONTENT_LENGTH), "123".parse().unwrap()))); assert_eq!(iter.next(), Some((None, "456".parse().unwrap()))); assert_eq!(iter.next(), Some((Some(header::CONTENT_TYPE), "json".parse().unwrap()))); assert_eq!(iter.next(), Some((None, "html".parse().unwrap()))); assert_eq!(iter.next(), Some((None, "xml".parse().unwrap()))); assert!(iter.next().is_none());
type Item = (Option<HeaderName>, T)
impl<Fut> IntoIterator for FuturesUnordered<Fut> where
Fut: Unpin,
impl<Fut> IntoIterator for FuturesUnordered<Fut> where
Fut: Unpin,
type Item = Fut
type IntoIter = IntoIter<Fut>
pub fn into_iter(self) -> <FuturesUnordered<Fut> as IntoIterator>::IntoIter
impl<'a, St> IntoIterator for &'a mut SelectAll<St> where
St: Stream + Unpin,
impl<'a, St> IntoIterator for &'a mut SelectAll<St> where
St: Stream + Unpin,
impl<'a, Fut> IntoIterator for &'a FuturesUnordered<Fut> where
Fut: Unpin,
impl<'a, Fut> IntoIterator for &'a FuturesUnordered<Fut> where
Fut: Unpin,
impl<St> IntoIterator for SelectAll<St> where
St: Stream + Unpin,
impl<St> IntoIterator for SelectAll<St> where
St: Stream + Unpin,
type Item = St
type IntoIter = IntoIter<St>
pub fn into_iter(self) -> <SelectAll<St> as IntoIterator>::IntoIter
impl<'a, St> IntoIterator for &'a SelectAll<St> where
St: Stream + Unpin,
impl<'a, St> IntoIterator for &'a SelectAll<St> where
St: Stream + Unpin,
impl<'a, Fut> IntoIterator for &'a mut FuturesUnordered<Fut> where
Fut: Unpin,
impl<'a, Fut> IntoIterator for &'a mut FuturesUnordered<Fut> where
Fut: Unpin,
impl<T> IntoIterator for RawTable<T>
impl<T> IntoIterator for RawTable<T>
impl<T, S> IntoIterator for HashSet<T, S>
impl<T, S> IntoIterator for HashSet<T, S>
Creates a consuming iterator, that is, one that moves each value out of the set in arbitrary order. The set cannot be used after calling this.
Examples
use hashbrown::HashSet; let mut set = HashSet::new(); set.insert("a".to_string()); set.insert("b".to_string()); // Not possible to collect to a Vec<String> with a regular `.iter()`. let v: Vec<String> = set.into_iter().collect(); // Will print in an arbitrary order. for x in &v { println!("{}", x); }
type Item = T
type IntoIter = IntoIter<T>
impl<'a, K, V, S> IntoIterator for &'a HashMap<K, V, S>
impl<'a, K, V, S> IntoIterator for &'a HashMap<K, V, S>
impl<'a, K, V, S> IntoIterator for &'a mut HashMap<K, V, S>
impl<'a, K, V, S> IntoIterator for &'a mut HashMap<K, V, S>
impl<K, V, S> IntoIterator for HashMap<K, V, S>
impl<K, V, S> IntoIterator for HashMap<K, V, S>
Creates a consuming iterator, that is, one that moves each key-value pair out of the map in arbitrary order. The map cannot be used after calling this.
Examples
use hashbrown::HashMap; let mut map = HashMap::new(); map.insert("a", 1); map.insert("b", 2); map.insert("c", 3); // Not possible with .iter() let vec: Vec<(&str, i32)> = map.into_iter().collect();
type IntoIter = IntoIter<K, V>
impl<'a, T, S> IntoIterator for &'a HashSet<T, S>
impl<'a, T, S> IntoIterator for &'a HashSet<T, S>
Implementors
impl IntoIterator for Dir
impl IntoIterator for Dir
pub fn into_iter(self) -> <Dir as IntoIterator>::IntoIter
pub fn into_iter(self) -> <Dir as IntoIterator>::IntoIter
Creates a owning iterator, that is, one that takes ownership of the
Dir
. The Dir
cannot be used after calling this. This can be useful
when you have a function that both creates a Dir
instance and returns
an Iterator
.
Example:
use nix::{dir::Dir, fcntl::OFlag, sys::stat::Mode}; use std::{iter::Iterator, string::String}; fn ls_upper(dirname: &str) -> impl Iterator<Item=String> { let d = Dir::open(dirname, OFlag::O_DIRECTORY, Mode::S_IXUSR).unwrap(); d.into_iter().map(|x| x.unwrap().file_name().as_ref().to_string_lossy().to_ascii_uppercase()) }
type IntoIter = OwningIter
impl IntoIterator for otter_api_tests::imports::regex::bytes::SetMatches
impl IntoIterator for otter_api_tests::imports::regex::bytes::SetMatches
type IntoIter = SetMatchesIntoIter
pub fn into_iter(self) -> <SetMatches as IntoIterator>::IntoIter
impl IntoIterator for otter_api_tests::imports::regex::SetMatches
impl IntoIterator for otter_api_tests::imports::regex::SetMatches
type IntoIter = SetMatchesIntoIter
pub fn into_iter(self) -> <SetMatches as IntoIterator>::IntoIter
impl<'a> IntoIterator for &'a otter_api_tests::imports::regex::bytes::SetMatches
impl<'a> IntoIterator for &'a otter_api_tests::imports::regex::bytes::SetMatches
type IntoIter = SetMatchesIter<'a>
pub fn into_iter(self) -> <&'a SetMatches as IntoIterator>::IntoIter
impl<'a> IntoIterator for &'a otter_api_tests::imports::regex::SetMatches
impl<'a> IntoIterator for &'a otter_api_tests::imports::regex::SetMatches
type IntoIter = SetMatchesIter<'a>
pub fn into_iter(self) -> <&'a SetMatches as IntoIterator>::IntoIter
Return an iterator from &RcIter<I>
(by simply cloning it).
impl<'a, I, T> IntoIterator for &'a IndexSlice<I, [T]> where
I: Idx,
impl<'a, I, T> IntoIterator for &'a IndexSlice<I, [T]> where
I: Idx,
impl<'a, I, T> IntoIterator for &'a otter_api_tests::shapelib::IndexVec<I, T> where
I: Idx,
impl<'a, I, T> IntoIterator for &'a otter_api_tests::shapelib::IndexVec<I, T> where
I: Idx,
impl<'a, I, T> IntoIterator for &'a mut IndexSlice<I, [T]> where
I: Idx,
impl<'a, I, T> IntoIterator for &'a mut IndexSlice<I, [T]> where
I: Idx,
impl<'a, I, T> IntoIterator for &'a mut otter_api_tests::shapelib::IndexVec<I, T> where
I: Idx,
impl<'a, I, T> IntoIterator for &'a mut otter_api_tests::shapelib::IndexVec<I, T> where
I: Idx,
impl<'a, K, V> IntoIterator for &'a EnumMap<K, V> where
K: Enum<V>,
impl<'a, K, V> IntoIterator for &'a EnumMap<K, V> where
K: Enum<V>,
impl<'a, K, V> IntoIterator for &'a mut EnumMap<K, V> where
K: Enum<V>,
impl<'a, K, V> IntoIterator for &'a mut EnumMap<K, V> where
K: Enum<V>,
impl<'a, K, V, S> IntoIterator for &'a SparseSecondaryMap<K, V, S> where
S: BuildHasher,
K: Key,
[src]
impl<'a, K, V, S> IntoIterator for &'a SparseSecondaryMap<K, V, S> where
S: BuildHasher,
K: Key,
[src]impl<'a, K, V, S> IntoIterator for &'a mut SparseSecondaryMap<K, V, S> where
S: BuildHasher,
K: Key,
[src]
impl<'a, K, V, S> IntoIterator for &'a mut SparseSecondaryMap<K, V, S> where
S: BuildHasher,
K: Key,
[src]impl<'a, T, N> IntoIterator for &'a GenericArray<T, N> where
T: 'a,
N: ArrayLength<T>,
impl<'a, T, N> IntoIterator for &'a GenericArray<T, N> where
T: 'a,
N: ArrayLength<T>,
pub fn into_iter(self) -> <&'a GenericArray<T, N> as IntoIterator>::IntoIter
impl<'a, T, N> IntoIterator for &'a mut GenericArray<T, N> where
T: 'a,
N: ArrayLength<T>,
impl<'a, T, N> IntoIterator for &'a mut GenericArray<T, N> where
T: 'a,
N: ArrayLength<T>,
pub fn into_iter(self) -> <&'a mut GenericArray<T, N> as IntoIterator>::IntoIter
impl<'a, T, const CAP: usize> IntoIterator for &'a otter_api_tests::shapelib::ArrayVec<T, CAP> where
T: 'a,
[src]
impl<'a, T, const CAP: usize> IntoIterator for &'a otter_api_tests::shapelib::ArrayVec<T, CAP> where
T: 'a,
[src]Iterate the ArrayVec
with references to each element.
use arrayvec::ArrayVec; let array = ArrayVec::from([1, 2, 3]); for elt in &array { // ... }
impl<'a, T, const CAP: usize> IntoIterator for &'a mut otter_api_tests::shapelib::ArrayVec<T, CAP> where
T: 'a,
[src]
impl<'a, T, const CAP: usize> IntoIterator for &'a mut otter_api_tests::shapelib::ArrayVec<T, CAP> where
T: 'a,
[src]Iterate the ArrayVec
with mutable references to each element.
use arrayvec::ArrayVec; let mut array = ArrayVec::from([1, 2, 3]); for elt in &mut array { // ... }
impl<'v, T, I> IntoIterator for &'v Deque<T, I> where
I: Offset,
impl<'v, T, I> IntoIterator for &'v Deque<T, I> where
I: Offset,
type IntoIter = impl Iterator<Item = <&'z IndexedZip as IntoIterator>::Item>
impl<I, T> IntoIterator for otter_api_tests::shapelib::IndexVec<I, T> where
I: Idx,
impl<I, T> IntoIterator for otter_api_tests::shapelib::IndexVec<I, T> where
I: Idx,
impl<K, V> IntoIterator for EnumMap<K, V> where
K: Enum<V>,
impl<K, V> IntoIterator for EnumMap<K, V> where
K: Enum<V>,
Creates a consuming iterator, that is, one that moves each key-value pair out of the map in arbitrary order. The map cannot be used after calling this.
Examples
use std::collections::HashMap; let mut map = HashMap::new(); map.insert("a", 1); map.insert("b", 2); map.insert("c", 3); // Not possible with .iter() let vec: Vec<(&str, i32)> = map.into_iter().collect();
Returns a consuming iterator over the possibly contained value.
The iterator yields one value if the result is Result::Ok
, otherwise none.
Examples
Basic usage:
let x: Result<u32, &str> = Ok(5); let v: Vec<u32> = x.into_iter().collect(); assert_eq!(v, [5]); let x: Result<u32, &str> = Err("nothing!"); let v: Vec<u32> = x.into_iter().collect(); assert_eq!(v, []);
type Item = T
impl<T, N> IntoIterator for GenericArray<T, N> where
N: ArrayLength<T>,
impl<T, N> IntoIterator for GenericArray<T, N> where
N: ArrayLength<T>,
type Item = T
type IntoIter = GenericArrayIter<T, N>
pub fn into_iter(self) -> <GenericArray<T, N> as IntoIterator>::IntoIter
Creates a consuming iterator, that is, one that moves each value out of the set in arbitrary order. The set cannot be used after calling this.
Examples
use std::collections::HashSet; let mut set = HashSet::new(); set.insert("a".to_string()); set.insert("b".to_string()); // Not possible to collect to a Vec<String> with a regular `.iter()`. let v: Vec<String> = set.into_iter().collect(); // Will print in an arbitrary order. for x in &v { println!("{}", x); }
type Item = T
Iterate the ArrayVec
with each element by value.
The vector is consumed by this operation.
use arrayvec::ArrayVec; for elt in ArrayVec::from([1, 2, 3]) { // ... }