Trait otter_api_tests::iter::IntoIterator
1.0.0 · source · [−]pub trait IntoIterator {
type Item;
type IntoIter: Iterator
where
<Self::IntoIter as Iterator>::Item == Self::Item;
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 = [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 = [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
1.6.0 · sourceimpl<'a> IntoIterator for &'a Path
impl<'a> IntoIterator for &'a Path
sourceimpl<'a, T> IntoIterator for &'a [T]
impl<'a, T> IntoIterator for &'a [T]
sourceimpl<'a, T, const N: usize> IntoIterator for &'a [T; N]
impl<'a, T, const N: usize> IntoIterator for &'a [T; N]
sourceimpl<'a, T, const N: usize> IntoIterator for &'a mut [T; N]
impl<'a, T, const N: usize> IntoIterator for &'a mut [T; N]
sourceimpl<'a, T> IntoIterator for &'a mut [T]
impl<'a, T> IntoIterator for &'a mut [T]
1.53.0 · sourceimpl<T, const N: usize> IntoIterator for [T; N]
impl<T, const N: usize> IntoIterator for [T; N]
sourcefn into_iter(self) -> <[T; N] as IntoIterator>::IntoIter
fn into_iter(self) -> <[T; N] as IntoIterator>::IntoIter
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
type IntoIter = IntoIter<T, N>
sourceimpl<T, A> IntoIterator for Vec<T, A> where
A: Allocator,
impl<T, A> IntoIterator for Vec<T, A> where
A: Allocator,
sourcefn into_iter(self) -> IntoIter<T, A>ⓘNotable traits for IntoIter<T, A>impl<T, A> Iterator for IntoIter<T, A> where
A: Allocator, type Item = T;
fn into_iter(self) -> IntoIter<T, A>ⓘNotable traits for IntoIter<T, A>impl<T, A> Iterator for IntoIter<T, A> where
A: Allocator, type Item = T;
A: Allocator, 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
type IntoIter = IntoIter<T, A>
sourceimpl<'a, T, A> IntoIterator for &'a mut Vec<T, A> where
A: Allocator,
impl<'a, T, A> IntoIterator for &'a mut Vec<T, A> where
A: Allocator,
sourceimpl<'a, T> IntoIterator for &'a mut LinkedList<T>
impl<'a, T> IntoIterator for &'a mut LinkedList<T>
sourceimpl<'a, T> IntoIterator for &'a BinaryHeap<T>
impl<'a, T> IntoIterator for &'a BinaryHeap<T>
sourceimpl<T> IntoIterator for LinkedList<T>
impl<T> IntoIterator for LinkedList<T>
sourceimpl<'a, T> IntoIterator for &'a LinkedList<T>
impl<'a, T> IntoIterator for &'a LinkedList<T>
sourceimpl<'a, T, A> IntoIterator for &'a Vec<T, A> where
A: Allocator,
impl<'a, T, A> IntoIterator for &'a Vec<T, A> where
A: Allocator,
sourceimpl<T> IntoIterator for BinaryHeap<T>
impl<T> IntoIterator for BinaryHeap<T>
sourcefn into_iter(self) -> IntoIter<T>ⓘNotable traits for IntoIter<T>impl<T> Iterator for IntoIter<T> type Item = T;
fn into_iter(self) -> IntoIter<T>ⓘNotable traits for IntoIter<T>impl<T> Iterator for IntoIter<T> 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([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
type IntoIter = IntoIter<T>
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
fn into_iter(self) -> <SmallVec<A> as IntoIterator>::IntoIter
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, A> IntoIterator for &'a SmallVec<A> where
A: Array,
impl<'a, A> IntoIterator for &'a SmallVec<A> where
A: Array,
impl<EntryData> IntoIterator for VecList<EntryData>
impl<EntryData> IntoIterator for VecList<EntryData>
type IntoIter = IntoIter<EntryData>
type Item = EntryData
fn into_iter(self) -> <VecList<EntryData> as IntoIterator>::IntoIter
impl<'entries, EntryData> IntoIterator for &'entries VecList<EntryData>
impl<'entries, EntryData> IntoIterator for &'entries VecList<EntryData>
impl<'entries, EntryData> IntoIterator for &'entries mut VecList<EntryData>
impl<'entries, EntryData> IntoIterator for &'entries mut VecList<EntryData>
type IntoIter = IterMut<'entries, EntryData>
type Item = &'entries mut EntryData
fn into_iter(
self
) -> <&'entries mut VecList<EntryData> as IntoIterator>::IntoIter
sourceimpl<'a, K, V> IntoIterator for &'a OrderedMap<K, V>
impl<'a, K, V> IntoIterator for &'a OrderedMap<K, V>
sourceimpl<'a, T> IntoIterator for &'a Set<T>
impl<'a, T> IntoIterator for &'a Set<T>
sourceimpl<'a, T> IntoIterator for &'a OrderedSet<T>
impl<'a, T> IntoIterator for &'a OrderedSet<T>
sourceimpl<'a, K, V> IntoIterator for &'a Map<K, V>
impl<'a, K, V> IntoIterator for &'a Map<K, V>
impl<'a> IntoIterator for &'a Utf8Sequence
impl<'a> IntoIterator for &'a Utf8Sequence
sourceimpl IntoIterator for Events
impl IntoIterator for Events
sourceimpl<'a> IntoIterator for &'a Events
impl<'a> IntoIterator for &'a Events
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<T> IntoIterator for Slab<T>
impl<T> IntoIterator for 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
type IntoIter = IntoIter<A, Global>
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<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
impl IntoIterator for CharRange
impl IntoIterator for CharRange
sourceimpl IntoIterator for IndexVec
impl IntoIterator for IndexVec
sourcefn into_iter(self) -> IndexVecIntoIterⓘNotable traits for IndexVecIntoIterimpl Iterator for IndexVecIntoIter type Item = usize;
fn into_iter(self) -> IndexVecIntoIterⓘNotable traits for IndexVecIntoIterimpl Iterator for IndexVecIntoIter type Item = usize;
Convert into an iterator over the indices as a sequence of usize
values
type Item = usize
type IntoIter = IndexVecIntoIter
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<T> IntoIterator for ThreadLocal<T> where
T: Send,
impl<T> IntoIterator for ThreadLocal<T> where
T: 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 CachedThreadLocal<T> where
T: 'a + Send,
impl<'a, T> IntoIterator for &'a mut CachedThreadLocal<T> where
T: 'a + 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<'a, A> IntoIterator for &'a mut TinyVec<A> where
A: Array,
impl<'a, A> IntoIterator for &'a mut TinyVec<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>
fn into_iter(self) -> <ArrayVec<A> as IntoIterator>::IntoIter
impl<'a, A> IntoIterator for &'a TinyVec<A> where
A: Array,
impl<'a, A> IntoIterator for &'a TinyVec<A> where
A: Array,
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>
fn into_iter(self) -> <TinyVec<A> as IntoIterator>::IntoIter
impl<'a, A> IntoIterator for &'a ArrayVec<A> where
A: Array,
impl<'a, A> IntoIterator for &'a 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 mut ArrayVec<A> where
A: Array,
impl<'a, A> IntoIterator for &'a mut ArrayVec<A> where
A: Array,
impl<'a> IntoIterator for &'a Events
impl<'a> IntoIterator for &'a Events
type Item = &'a Event
type IntoIter = Iter<'a>
fn into_iter(self) -> <&'a Events as IntoIterator>::IntoIter
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>
impl<T> IntoIterator for VecMap<T>
impl<T> IntoIterator for VecMap<T>
fn into_iter(self) -> IntoIter<T>ⓘNotable traits for IntoIter<V>impl<V> Iterator for IntoIter<V> type Item = (usize, V);
fn into_iter(self) -> IntoIter<T>ⓘNotable traits for IntoIter<V>impl<V> Iterator for IntoIter<V> type Item = (usize, V);
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 Item = (usize, T)
type IntoIter = IntoIter<T>
sourceimpl<'a, T> IntoIterator for &'a mut HeaderMap<T>
impl<'a, T> IntoIterator for &'a mut HeaderMap<T>
sourceimpl<'a, 'b, T> IntoIterator for &'b mut OccupiedEntry<'a, T> where
'b: 'a,
impl<'a, 'b, T> IntoIterator for &'b mut OccupiedEntry<'a, T> where
'b: 'a,
type Item = &'a mut T
type IntoIter = ValueIterMut<'a, T>
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;
T: 'a, type Item = &'a mut T;
sourceimpl<T> IntoIterator for HeaderMap<T>
impl<T> IntoIterator for HeaderMap<T>
sourcefn into_iter(self) -> IntoIter<T>ⓘNotable traits for IntoIter<T>impl<T> Iterator for IntoIter<T> type Item = (Option<HeaderName>, T);
fn into_iter(self) -> IntoIter<T>ⓘNotable traits for IntoIter<T>impl<T> Iterator for IntoIter<T> type Item = (Option<HeaderName>, T);
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)
type IntoIter = IntoIter<T>
sourceimpl<'a, T> IntoIterator for &'a HeaderMap<T>
impl<'a, T> IntoIterator for &'a HeaderMap<T>
sourceimpl<'a, 'b, T> IntoIterator for &'b GetAll<'a, T> where
'b: 'a,
impl<'a, 'b, T> IntoIterator for &'b GetAll<'a, T> where
'b: 'a,
sourceimpl<'a, 'b, T> IntoIterator for &'b OccupiedEntry<'a, T> where
'b: 'a,
impl<'a, 'b, T> IntoIterator for &'b OccupiedEntry<'a, T> where
'b: 'a,
sourceimpl<'a, T> IntoIterator for OccupiedEntry<'a, T>
impl<'a, T> IntoIterator for OccupiedEntry<'a, T>
type Item = &'a mut T
type IntoIter = ValueIterMut<'a, T>
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;
T: 'a, type Item = &'a mut T;
sourceimpl<'a, T> IntoIterator for GetAll<'a, T>
impl<'a, T> IntoIterator for GetAll<'a, T>
impl<'a> IntoIterator for &'a BytesMut
impl<'a> IntoIterator for &'a BytesMut
impl IntoIterator for Bytes
impl IntoIterator for Bytes
impl IntoIterator for BytesMut
impl IntoIterator for BytesMut
impl<'a> IntoIterator for &'a Bytes
impl<'a> IntoIterator for &'a Bytes
impl<T, U> IntoIterator for Chain<T, U> where
T: Buf,
U: Buf,
impl<T, U> IntoIterator for Chain<T, U> where
T: Buf,
U: Buf,
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>
fn into_iter(self) -> <SelectAll<St> as IntoIterator>::IntoIter
impl<'a, Fut> IntoIterator for &'a FuturesUnordered<Fut> where
Fut: Unpin,
impl<'a, Fut> IntoIterator for &'a FuturesUnordered<Fut> where
Fut: Unpin,
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 mut FuturesUnordered<Fut> where
Fut: Unpin,
impl<'a, Fut> IntoIterator for &'a mut FuturesUnordered<Fut> where
Fut: Unpin,
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<Fut> IntoIterator for FuturesUnordered<Fut> where
Fut: Unpin,
impl<Fut> IntoIterator for FuturesUnordered<Fut> where
Fut: Unpin,
type Item = Fut
type IntoIter = IntoIter<Fut>
fn into_iter(self) -> <FuturesUnordered<Fut> as IntoIterator>::IntoIter
sourceimpl<'a> IntoIterator for &'a FieldSet
impl<'a> IntoIterator for &'a FieldSet
sourceimpl<T, S> IntoIterator for IndexSet<T, S>
impl<T, S> IntoIterator for IndexSet<T, S>
sourceimpl<K, V, S> IntoIterator for IndexMap<K, V, S>
impl<K, V, S> IntoIterator for IndexMap<K, V, S>
sourceimpl<'a, K, V, S> IntoIterator for &'a mut IndexMap<K, V, S>
impl<'a, K, V, S> IntoIterator for &'a mut IndexMap<K, V, S>
sourceimpl<'a, K, V, S> IntoIterator for &'a IndexMap<K, V, S>
impl<'a, K, V, S> IntoIterator for &'a IndexMap<K, V, S>
sourceimpl<'a, T, S> IntoIterator for &'a IndexSet<T, S>
impl<'a, T, S> IntoIterator for &'a IndexSet<T, S>
impl<'a, T, S, A> IntoIterator for &'a HashSet<T, S, A> where
A: Allocator + Clone,
impl<'a, T, S, A> IntoIterator for &'a HashSet<T, S, A> where
A: Allocator + Clone,
impl<T, A> IntoIterator for RawTable<T, A> where
A: Allocator + Clone,
impl<T, A> IntoIterator for RawTable<T, A> where
A: Allocator + Clone,
impl<'a, K, V, S, A> IntoIterator for &'a HashMap<K, V, S, A> where
A: Allocator + Clone,
impl<'a, K, V, S, A> IntoIterator for &'a HashMap<K, V, S, A> where
A: Allocator + Clone,
impl<T, S, A> IntoIterator for HashSet<T, S, A> where
A: Allocator + Clone,
impl<T, S, A> IntoIterator for HashSet<T, S, A> where
A: Allocator + Clone,
fn into_iter(self) -> IntoIter<T, A>ⓘNotable traits for IntoIter<K, A>impl<K, A> Iterator for IntoIter<K, A> where
A: Allocator + Clone, type Item = K;
fn into_iter(self) -> IntoIter<T, A>ⓘNotable traits for IntoIter<K, A>impl<K, A> Iterator for IntoIter<K, A> where
A: Allocator + Clone, type Item = K;
A: Allocator + Clone, type Item = K;
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, A>
impl<K, V, S, A> IntoIterator for HashMap<K, V, S, A> where
A: Allocator + Clone,
impl<K, V, S, A> IntoIterator for HashMap<K, V, S, A> where
A: Allocator + Clone,
fn into_iter(self) -> IntoIter<K, V, A>ⓘNotable traits for IntoIter<K, V, A>impl<K, V, A> Iterator for IntoIter<K, V, A> where
A: Allocator + Clone, type Item = (K, V);
fn into_iter(self) -> IntoIter<K, V, A>ⓘNotable traits for IntoIter<K, V, A>impl<K, V, A> Iterator for IntoIter<K, V, A> where
A: Allocator + Clone, type Item = (K, V);
A: Allocator + Clone, type Item = (K, 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 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 Item = (K, V)
type IntoIter = IntoIter<K, V, A>
impl<'a, K, V, S, A> IntoIterator for &'a mut HashMap<K, V, S, A> where
A: Allocator + Clone,
impl<'a, K, V, S, A> IntoIterator for &'a mut HashMap<K, V, S, A> where
A: Allocator + Clone,
sourceimpl<'a, T> IntoIterator for &'a mut Stack<T> where
T: Stackable,
impl<'a, T> IntoIterator for &'a mut Stack<T> where
T: Stackable,
sourceimpl<'a, T> IntoIterator for &'a Stack<T> where
T: Stackable,
impl<'a, T> IntoIterator for &'a Stack<T> where
T: Stackable,
sourceimpl<'a, T> IntoIterator for &'a StackRef<T> where
T: Stackable,
impl<'a, T> IntoIterator for &'a StackRef<T> where
T: Stackable,
sourceimpl<T> IntoIterator for Stack<T> where
T: Stackable,
impl<T> IntoIterator for Stack<T> where
T: Stackable,
sourceimpl<'a, T> IntoIterator for &'a mut StackRef<T> where
T: Stackable,
impl<'a, T> IntoIterator for &'a mut StackRef<T> where
T: Stackable,
Implementors
impl IntoIterator for Dir
impl IntoIterator for Dir
impl IntoIterator for otter_api_tests::imports::regex::bytes::SetMatches
impl IntoIterator for otter_api_tests::imports::regex::bytes::SetMatches
type IntoIter = SetMatchesIntoIter
type Item = usize
impl IntoIterator for otter_api_tests::imports::regex::SetMatches
impl IntoIterator for otter_api_tests::imports::regex::SetMatches
type IntoIter = SetMatchesIntoIter
type Item = usize
sourceimpl IntoIterator for otter_api_tests::imports::toml::value::Map<String, Value>
impl IntoIterator for otter_api_tests::imports::toml::value::Map<String, Value>
sourceimpl IntoIterator for otter_api_tests::serde_json::Map<String, Value>
impl IntoIterator for otter_api_tests::serde_json::Map<String, Value>
impl<'a> IntoIterator for &'a Interfaces
impl<'a> IntoIterator for &'a Interfaces
type IntoIter = InterfacesIter<'a>
type Item = &'a Interface
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>
type Item = usize
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>
type Item = usize
sourceimpl<'a> IntoIterator for &'a otter_api_tests::imports::toml::value::Map<String, Value>
impl<'a> IntoIterator for &'a otter_api_tests::imports::toml::value::Map<String, Value>
sourceimpl<'a> IntoIterator for &'a otter_api_tests::serde_json::Map<String, Value>
impl<'a> IntoIterator for &'a otter_api_tests::serde_json::Map<String, Value>
1.10.0 · sourceimpl<'a> IntoIterator for &'a UnixListener
impl<'a> IntoIterator for &'a UnixListener
sourceimpl<'a> IntoIterator for &'a mut otter_api_tests::imports::toml::value::Map<String, Value>
impl<'a> IntoIterator for &'a mut otter_api_tests::imports::toml::value::Map<String, Value>
sourceimpl<'a> IntoIterator for &'a mut otter_api_tests::serde_json::Map<String, Value>
impl<'a> IntoIterator for &'a mut otter_api_tests::serde_json::Map<String, Value>
sourceimpl<'a, I> IntoIterator for &'a IntoChunks<I> where
I: Iterator,
<I as Iterator>::Item: 'a,
impl<'a, I> IntoIterator for &'a IntoChunks<I> where
I: Iterator,
<I as Iterator>::Item: 'a,
sourceimpl<'a, I> IntoIterator for &'a RcIter<I> where
I: Iterator,
impl<'a, I> IntoIterator for &'a RcIter<I> where
I: Iterator,
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,
sourceimpl<'a, K, I, F> IntoIterator for &'a GroupBy<K, I, F> where
I: Iterator,
F: FnMut(&<I as Iterator>::Item) -> K,
K: PartialEq<K>,
<I as Iterator>::Item: 'a,
impl<'a, K, I, F> IntoIterator for &'a GroupBy<K, I, F> where
I: Iterator,
F: FnMut(&<I as Iterator>::Item) -> K,
K: PartialEq<K>,
<I as Iterator>::Item: 'a,
sourceimpl<'a, K, V> IntoIterator for &'a HopSlotMap<K, V> where
K: Key,
impl<'a, K, V> IntoIterator for &'a HopSlotMap<K, V> where
K: Key,
sourceimpl<'a, K, V> IntoIterator for &'a SecondaryMap<K, V> where
K: Key,
impl<'a, K, V> IntoIterator for &'a SecondaryMap<K, V> where
K: Key,
sourceimpl<'a, K, V> IntoIterator for &'a SlotMap<K, V> where
K: Key,
impl<'a, K, V> IntoIterator for &'a SlotMap<K, V> where
K: Key,
sourceimpl<'a, K, V> IntoIterator for &'a BTreeMap<K, V>
impl<'a, K, V> IntoIterator for &'a BTreeMap<K, V>
sourceimpl<'a, K, V> IntoIterator for &'a DenseSlotMap<K, V> where
K: 'a + Key,
impl<'a, K, V> IntoIterator for &'a DenseSlotMap<K, V> where
K: 'a + Key,
impl<'a, K, V> IntoIterator for &'a EnumMap<K, V> where
K: EnumArray<V>,
impl<'a, K, V> IntoIterator for &'a EnumMap<K, V> where
K: EnumArray<V>,
sourceimpl<'a, K, V> IntoIterator for &'a mut HopSlotMap<K, V> where
K: Key,
impl<'a, K, V> IntoIterator for &'a mut HopSlotMap<K, V> where
K: Key,
sourceimpl<'a, K, V> IntoIterator for &'a mut SecondaryMap<K, V> where
K: Key,
impl<'a, K, V> IntoIterator for &'a mut SecondaryMap<K, V> where
K: Key,
sourceimpl<'a, K, V> IntoIterator for &'a mut SlotMap<K, V> where
K: Key,
impl<'a, K, V> IntoIterator for &'a mut SlotMap<K, V> where
K: Key,
sourceimpl<'a, K, V> IntoIterator for &'a mut BTreeMap<K, V>
impl<'a, K, V> IntoIterator for &'a mut BTreeMap<K, V>
sourceimpl<'a, K, V> IntoIterator for &'a mut DenseSlotMap<K, V> where
K: 'a + Key,
impl<'a, K, V> IntoIterator for &'a mut DenseSlotMap<K, V> where
K: 'a + Key,
impl<'a, K, V> IntoIterator for &'a mut EnumMap<K, V> where
K: EnumArray<V>,
impl<'a, K, V> IntoIterator for &'a mut EnumMap<K, V> where
K: EnumArray<V>,
sourceimpl<'a, K, V, S> IntoIterator for &'a otter_api_tests::shapelib::HashMap<K, V, S>
impl<'a, K, V, S> IntoIterator for &'a otter_api_tests::shapelib::HashMap<K, V, S>
sourceimpl<'a, K, V, S> IntoIterator for &'a SparseSecondaryMap<K, V, S> where
K: Key,
S: BuildHasher,
impl<'a, K, V, S> IntoIterator for &'a SparseSecondaryMap<K, V, S> where
K: Key,
S: BuildHasher,
sourceimpl<'a, K, V, S> IntoIterator for &'a mut otter_api_tests::shapelib::HashMap<K, V, S>
impl<'a, K, V, S> IntoIterator for &'a mut otter_api_tests::shapelib::HashMap<K, V, S>
sourceimpl<'a, K, V, S> IntoIterator for &'a mut SparseSecondaryMap<K, V, S> where
K: Key,
S: BuildHasher,
impl<'a, K, V, S> IntoIterator for &'a mut SparseSecondaryMap<K, V, S> where
K: Key,
S: BuildHasher,
1.4.0 · sourceimpl<'a, T> IntoIterator for &'a Option<T>
impl<'a, T> IntoIterator for &'a Option<T>
1.4.0 · sourceimpl<'a, T> IntoIterator for &'a mut Option<T>
impl<'a, T> IntoIterator for &'a mut Option<T>
sourceimpl<'a, T, A> IntoIterator for &'a VecDeque<T, A> where
A: Allocator,
impl<'a, T, A> IntoIterator for &'a VecDeque<T, A> where
A: Allocator,
sourceimpl<'a, T, A> IntoIterator for &'a mut VecDeque<T, A> where
A: Allocator,
impl<'a, T, A> IntoIterator for &'a mut VecDeque<T, A> where
A: Allocator,
1.4.0 · sourceimpl<'a, T, E> IntoIterator for &'a Result<T, E>
impl<'a, T, E> IntoIterator for &'a Result<T, E>
1.4.0 · sourceimpl<'a, T, E> IntoIterator for &'a mut Result<T, E>
impl<'a, T, E> IntoIterator for &'a mut Result<T, E>
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>,
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>,
sourceimpl<'a, T, S> IntoIterator for &'a otter_api_tests::shapelib::HashSet<T, S>
impl<'a, T, S> IntoIterator for &'a otter_api_tests::shapelib::HashSet<T, S>
sourceimpl<'a, T, const CAP: usize> IntoIterator for &'a otter_api_tests::shapelib::ArrayVec<T, CAP> where
T: 'a,
impl<'a, T, const CAP: usize> IntoIterator for &'a otter_api_tests::shapelib::ArrayVec<T, CAP> where
T: 'a,
Iterate the ArrayVec
with references to each element.
use arrayvec::ArrayVec;
let array = ArrayVec::from([1, 2, 3]);
for elt in &array {
// ...
}
sourceimpl<'a, T, const CAP: usize> IntoIterator for &'a mut otter_api_tests::shapelib::ArrayVec<T, CAP> where
T: 'a,
impl<'a, T, const CAP: usize> IntoIterator for &'a mut otter_api_tests::shapelib::ArrayVec<T, CAP> where
T: 'a,
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 {
// ...
}
sourceimpl<'p> IntoIterator for &'p mut GPieces
impl<'p> IntoIterator for &'p mut GPieces
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,
sourceimpl<'z> IntoIterator for &'z IndexedZip
impl<'z> IntoIterator for &'z IndexedZip
sourceimpl<I> IntoIterator for I where
I: Iterator,
impl<I> IntoIterator for I where
I: Iterator,
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,
sourceimpl<K, V> IntoIterator for HopSlotMap<K, V> where
K: Key,
impl<K, V> IntoIterator for HopSlotMap<K, V> where
K: Key,
sourceimpl<K, V> IntoIterator for SecondaryMap<K, V> where
K: Key,
impl<K, V> IntoIterator for SecondaryMap<K, V> where
K: Key,
sourceimpl<K, V> IntoIterator for SlotMap<K, V> where
K: Key,
impl<K, V> IntoIterator for SlotMap<K, V> where
K: Key,
sourceimpl<K, V> IntoIterator for DenseSlotMap<K, V> where
K: Key,
impl<K, V> IntoIterator for DenseSlotMap<K, V> where
K: Key,
impl<K, V> IntoIterator for EnumMap<K, V> where
K: EnumArray<V>,
impl<K, V> IntoIterator for EnumMap<K, V> where
K: EnumArray<V>,
sourceimpl<K, V, S> IntoIterator for otter_api_tests::shapelib::HashMap<K, V, S>
impl<K, V, S> IntoIterator for otter_api_tests::shapelib::HashMap<K, V, S>
sourceimpl<K, V, S> IntoIterator for SparseSecondaryMap<K, V, S> where
K: Key,
S: BuildHasher,
impl<K, V, S> IntoIterator for SparseSecondaryMap<K, V, S> where
K: Key,
S: BuildHasher,
sourceimpl<T, A> IntoIterator for VecDeque<T, A> where
A: Allocator,
impl<T, A> IntoIterator for VecDeque<T, A> where
A: Allocator,
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>
sourceimpl<T, S> IntoIterator for otter_api_tests::shapelib::HashSet<T, S>
impl<T, S> IntoIterator for otter_api_tests::shapelib::HashSet<T, S>
sourceimpl<T, const CAP: usize> IntoIterator for otter_api_tests::shapelib::ArrayVec<T, CAP>
impl<T, const CAP: usize> IntoIterator for otter_api_tests::shapelib::ArrayVec<T, CAP>
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]) {
// ...
}