Trait af_lib::iter::__std_iter::IntoIterator

pub trait IntoIterator {
    type Item;
    type IntoIter: Iterator;
#[lang = "into_iter"]    pub fn into_iter(self) -> Self::IntoIter;
}

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

type Item

The type of the elements being iterated over.

type IntoIter: Iterator

Which kind of iterator are we turning this into?

Loading content...

Required methods

#[lang = "into_iter"]pub fn into_iter(self) -> Self::IntoIter

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());

Loading content...

Implementations on Foreign Types

impl<T> IntoIterator for Receiver<T>

type Item = T

type IntoIter = IntoIter<T>

pub fn into_iter(self) -> IntoIter<T>

impl<'a, T> IntoIterator for &'a Receiver<T>

type Item = T

type IntoIter = Iter<'a, T>

pub fn into_iter(self) -> Iter<'a, T>

impl<'a, K, V, S> IntoIterator for &'a HashMap<K, V, S>

type Item = (&'a K, &'a V)

type IntoIter = Iter<'a, K, V>

pub fn into_iter(self) -> Iter<'a, K, V>

impl<'a> IntoIterator for &'a Path

type Item = &'a OsStr

type IntoIter = Iter<'a>

pub fn into_iter(self) -> Iter<'a>

impl<'a> IntoIterator for &'a PathBuf

type Item = &'a OsStr

type IntoIter = Iter<'a>

pub fn into_iter(self) -> Iter<'a>

impl<'a, K, V, S> IntoIterator for &'a mut HashMap<K, V, S>

type Item = (&'a K, &'a mut V)

type IntoIter = IterMut<'a, K, V>

pub fn into_iter(self) -> IterMut<'a, K, V>

impl<'a> IntoIterator for &'a UnixListener

type Item = Result<UnixStream, Error>

type IntoIter = Incoming<'a>

pub fn into_iter(self) -> Incoming<'a>

impl<'a, T, S> IntoIterator for &'a HashSet<T, S>

type Item = &'a T

type IntoIter = Iter<'a, T>

pub fn into_iter(self) -> Iter<'a, T>

impl<T, S> IntoIterator for HashSet<T, S>

type Item = T

type IntoIter = IntoIter<T>

pub fn into_iter(self) -> IntoIter<T>

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);
}

impl<K, V, S> IntoIterator for HashMap<K, V, S>

type Item = (K, V)

type IntoIter = IntoIter<K, V>

pub fn into_iter(self) -> IntoIter<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 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();

impl<'a, T, E> IntoIterator for &'a Result<T, E>

type Item = &'a T

type IntoIter = Iter<'a, T>

pub fn into_iter(self) -> Iter<'a, T>

impl<'a, T, const N: usize> IntoIterator for &'a [T; N]

type Item = &'a T

type IntoIter = Iter<'a, T>

pub fn into_iter(self) -> Iter<'a, T>

impl<T, E> IntoIterator for Result<T, E>

type Item = T

type IntoIter = IntoIter<T>

pub fn into_iter(self) -> IntoIter<T>

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, []);

impl<'a, T> IntoIterator for &'a mut Option<T>

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

pub fn into_iter(self) -> IterMut<'a, T>

impl<'a, T> IntoIterator for &'a [T]

type Item = &'a T

type IntoIter = Iter<'a, T>

pub fn into_iter(self) -> Iter<'a, T>

impl<'a, T, const N: usize> IntoIterator for &'a mut [T; N]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

pub fn into_iter(self) -> IterMut<'a, T>

impl<'a, T, E> IntoIterator for &'a mut Result<T, E>

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

pub fn into_iter(self) -> IterMut<'a, T>

impl<T> IntoIterator for Option<T>

type Item = T

type IntoIter = IntoIter<T>

pub fn into_iter(self) -> IntoIter<T>

Returns a consuming iterator over the possibly contained value.

Examples

let x = Some("string");
let v: Vec<&str> = x.into_iter().collect();
assert_eq!(v, ["string"]);

let x = None;
let v: Vec<&str> = x.into_iter().collect();
assert!(v.is_empty());

impl<'a, T> IntoIterator for &'a mut [T]

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

pub fn into_iter(self) -> IterMut<'a, T>

impl<'a, T> IntoIterator for &'a Option<T>

type Item = &'a T

type IntoIter = Iter<'a, T>

pub fn into_iter(self) -> Iter<'a, T>

impl<'a, T> IntoIterator for &'a VecDeque<T>

type Item = &'a T

type IntoIter = Iter<'a, T>

pub fn into_iter(self) -> Iter<'a, T>

impl<'a, T, A> IntoIterator for &'a mut Vec<T, A> where
    A: Allocator, 

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

pub fn into_iter(self) -> IterMut<'a, T>

impl<'a, T> IntoIterator for &'a mut VecDeque<T>

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

pub fn into_iter(self) -> IterMut<'a, T>

impl<'a, T> IntoIterator for &'a mut LinkedList<T>

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

pub fn into_iter(self) -> IterMut<'a, T>

impl<'a, K, V> IntoIterator for &'a BTreeMap<K, V>

type Item = (&'a K, &'a V)

type IntoIter = Iter<'a, K, V>

pub fn into_iter(self) -> Iter<'a, K, V>

impl<'a, T> IntoIterator for &'a BTreeSet<T>

type Item = &'a T

type IntoIter = Iter<'a, T>

pub fn into_iter(self) -> Iter<'a, T>

impl<'a, T> IntoIterator for &'a LinkedList<T>

type Item = &'a T

type IntoIter = Iter<'a, T>

pub fn into_iter(self) -> Iter<'a, T>

impl<T> IntoIterator for BinaryHeap<T>

type Item = T

type IntoIter = IntoIter<T>

pub fn into_iter(self) -> IntoIter<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);
}

impl<T> IntoIterator for LinkedList<T>

type Item = T

type IntoIter = IntoIter<T>

pub fn into_iter(self) -> IntoIter<T>

Consumes the list into an iterator yielding elements by value.

impl<'a, T> IntoIterator for &'a BinaryHeap<T>

type Item = &'a T

type IntoIter = Iter<'a, T>

pub fn into_iter(self) -> Iter<'a, T>

impl<K, V> IntoIterator for BTreeMap<K, V>

type Item = (K, V)

type IntoIter = IntoIter<K, V>

pub fn into_iter(self) -> IntoIter<K, V>

impl<'a, T, A> IntoIterator for &'a Vec<T, A> where
    A: Allocator, 

type Item = &'a T

type IntoIter = Iter<'a, T>

pub fn into_iter(self) -> Iter<'a, T>

impl<'a, K, V> IntoIterator for &'a mut BTreeMap<K, V>

type Item = (&'a K, &'a mut V)

type IntoIter = IterMut<'a, K, V>

pub fn into_iter(self) -> IterMut<'a, K, V>

impl<T> IntoIterator for VecDeque<T>

type Item = T

type IntoIter = IntoIter<T>

pub fn into_iter(self) -> IntoIter<T>

Consumes the VecDeque into a front-to-back iterator yielding elements by value.

impl<T, A> IntoIterator for Vec<T, A> where
    A: Allocator, 

type Item = T

type IntoIter = IntoIter<T, A>

pub fn into_iter(self) -> IntoIter<T, A>

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);
}

impl<T> IntoIterator for BTreeSet<T>

type Item = T

type IntoIter = IntoIter<T>

pub fn into_iter(self) -> IntoIter<T>

Gets an iterator for moving out the BTreeSet's contents.

Examples

use std::collections::BTreeSet;

let set: BTreeSet<usize> = [1, 2, 3, 4].iter().cloned().collect();

let v: Vec<_> = set.into_iter().collect();
assert_eq!(v, [1, 2, 3, 4]);

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

impl<'a, A> IntoIterator for &'a SmallVec<A> where
    A: Array, 

type IntoIter = Iter<'a, <A as Array>::Item>

type Item = &'a <A as Array>::Item

pub fn into_iter(self) -> <&'a SmallVec<A> as IntoIterator>::IntoIter

impl<'a, A> IntoIterator for &'a mut SmallVec<A> where
    A: Array, 

type IntoIter = IterMut<'a, <A as Array>::Item>

type Item = &'a mut <A as Array>::Item

pub fn into_iter(self) -> <&'a mut SmallVec<A> as IntoIterator>::IntoIter

impl IntoIterator for IndexVec

type Item = usize

type IntoIter = IndexVecIntoIter

pub fn into_iter(self) -> IndexVecIntoIter

Convert into an iterator over the indices as a sequence of usize values

impl<'a, E> IntoIterator for &'a mut SignalsInfo<E> where
    E: Exfiltrator, 

type Item = <E as Exfiltrator>::Output

type IntoIter = Forever<'a, E>

pub fn into_iter(self) -> <&'a mut SignalsInfo<E> as IntoIterator>::IntoIter

impl IntoIterator for SetMatches

type IntoIter = SetMatchesIntoIter

type Item = usize

pub fn into_iter(self) -> <SetMatches as IntoIterator>::IntoIter

impl<'a> IntoIterator for &'a SetMatches

type IntoIter = SetMatchesIter<'a>

type Item = usize

pub fn into_iter(self) -> <&'a SetMatches as IntoIterator>::IntoIter

impl<'a> IntoIterator for &'a SetMatches

type IntoIter = SetMatchesIter<'a>

type Item = usize

pub fn into_iter(self) -> <&'a SetMatches as IntoIterator>::IntoIter

impl IntoIterator for SetMatches

type IntoIter = SetMatchesIntoIter

type Item = usize

pub fn into_iter(self) -> <SetMatches as IntoIterator>::IntoIter

impl<'a> IntoIterator for &'a Utf8Sequence

type IntoIter = Iter<'a, Utf8Range>

type Item = &'a Utf8Range

pub fn into_iter(self) -> <&'a Utf8Sequence as IntoIterator>::IntoIter

impl<T> IntoIterator for ThreadLocal<T> where
    T: Send, 

type Item = T

type IntoIter = IntoIter<T>

pub fn into_iter(self) -> IntoIter<T>

impl<'a, T> IntoIterator for &'a mut CachedThreadLocal<T> where
    T: 'a + Send, 

type Item = &'a mut T

type IntoIter = CachedIterMut<'a, T>

pub fn into_iter(self) -> CachedIterMut<'a, T>

impl<'a, T> IntoIterator for &'a mut ThreadLocal<T> where
    T: Send, 

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

pub fn into_iter(self) -> IterMut<'a, T>

impl<'a, T> IntoIterator for &'a ThreadLocal<T> where
    T: Send + Sync, 

type Item = &'a T

type IntoIter = Iter<'a, T>

pub fn into_iter(self) -> <&'a ThreadLocal<T> as IntoIterator>::IntoIter

impl<T> IntoIterator for CachedThreadLocal<T> where
    T: Send, 

type Item = T

type IntoIter = CachedIntoIter<T>

pub fn into_iter(self) -> CachedIntoIter<T>

impl<'a, K, V, S> IntoIterator for DashMap<K, V, S> where
    S: Clone + BuildHasher,
    K: Eq + Hash, 

type Item = (K, V)

type IntoIter = OwningIter<K, V, S>

pub fn into_iter(self) -> <DashMap<K, V, S> as IntoIterator>::IntoIter

impl<'a, K, S> IntoIterator for DashSet<K, S> where
    S: Clone + BuildHasher,
    K: Eq + Hash, 

type Item = K

type IntoIter = OwningIter<K, S>

pub fn into_iter(self) -> <DashSet<K, S> as IntoIterator>::IntoIter

impl<'a, K, V, S> IntoIterator for &'a DashMap<K, V, S> where
    S: Clone + BuildHasher,
    K: Eq + Hash, 

type Item = RefMulti<'a, K, V, S>

type IntoIter = Iter<'a, K, V, S, DashMap<K, V, S>>

pub fn into_iter(self) -> <&'a DashMap<K, V, S> as IntoIterator>::IntoIter

impl<'a> IntoIterator for &'a Bytes

type Item = &'a u8

type IntoIter = Iter<'a, u8>

pub fn into_iter(self) -> <&'a Bytes as IntoIterator>::IntoIter

impl IntoIterator for BytesMut

type Item = u8

type IntoIter = IntoIter<BytesMut>

pub fn into_iter(self) -> <BytesMut as IntoIterator>::IntoIter

impl<T, U> IntoIterator for Chain<T, U> where
    T: Buf,
    U: Buf, 

type Item = u8

type IntoIter = IntoIter<Chain<T, U>>

pub fn into_iter(self) -> <Chain<T, U> as IntoIterator>::IntoIter

impl IntoIterator for Bytes

type Item = u8

type IntoIter = IntoIter<Bytes>

pub fn into_iter(self) -> <Bytes as IntoIterator>::IntoIter

impl<'a> IntoIterator for &'a BytesMut

type Item = &'a u8

type IntoIter = Iter<'a, u8>

pub fn into_iter(self) -> <&'a BytesMut as IntoIterator>::IntoIter

impl<'a, T, N> IntoIterator for &'a mut GenericArray<T, N> where
    N: ArrayLength<T>,
    T: 'a, 

type IntoIter = IterMut<'a, T>

type Item = &'a mut T

pub fn into_iter(self) -> <&'a mut GenericArray<T, N> as IntoIterator>::IntoIter

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

impl<'a, T, N> IntoIterator for &'a GenericArray<T, N> where
    N: ArrayLength<T>,
    T: 'a, 

type IntoIter = Iter<'a, T>

type Item = &'a T

pub fn into_iter(self) -> <&'a GenericArray<T, N> as IntoIterator>::IntoIter

impl<'a, A> IntoIterator for &'a mut ArrayVec<A> where
    A: Array, 

type Item = &'a mut <A as Array>::Item

type IntoIter = IterMut<'a, <A as Array>::Item>

#[must_use]pub fn into_iter(self) -> <&'a mut ArrayVec<A> as IntoIterator>::IntoIter

impl<'s, T> IntoIterator for SliceVec<'s, T>

type Item = &'s mut T

type IntoIter = IterMut<'s, T>

#[must_use]pub fn into_iter(self) -> <SliceVec<'s, T> as IntoIterator>::IntoIter

impl<'a, A> IntoIterator for &'a ArrayVec<A> where
    A: Array, 

type Item = &'a <A as Array>::Item

type IntoIter = Iter<'a, <A as Array>::Item>

#[must_use]pub fn into_iter(self) -> <&'a ArrayVec<A> as IntoIterator>::IntoIter

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, A> IntoIterator for &'a TinyVec<A> where
    A: Array, 

type Item = &'a <A as Array>::Item

type IntoIter = Iter<'a, <A as Array>::Item>

#[must_use]pub fn into_iter(self) -> <&'a TinyVec<A> as IntoIterator>::IntoIter

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, 

type Item = &'a mut <A as Array>::Item

type IntoIter = IterMut<'a, <A as Array>::Item>

#[must_use]pub fn into_iter(self) -> <&'a mut TinyVec<A> as IntoIterator>::IntoIter

impl<A> IntoIterator for OrdSet<A> where
    A: Ord + Clone, 

type Item = A

type IntoIter = ConsumingIter<A>

pub fn into_iter(self) -> <OrdSet<A> as IntoIterator>::IntoIter

impl<K, V> IntoIterator for OrdMap<K, V> where
    V: Clone,
    K: Ord + Clone, 

type Item = (K, V)

type IntoIter = ConsumingIter<(K, V)>

pub fn into_iter(self) -> <OrdMap<K, V> as IntoIterator>::IntoIter

impl<'a, A, S> IntoIterator for &'a HashSet<A, S> where
    A: Hash + Eq,
    S: BuildHasher, 

type Item = &'a A

type IntoIter = Iter<'a, A>

pub fn into_iter(self) -> <&'a HashSet<A, S> as IntoIterator>::IntoIter

impl<A> IntoIterator for Vector<A> where
    A: Clone, 

type Item = A

type IntoIter = ConsumingIter<A>

pub fn into_iter(self) -> <Vector<A> as IntoIterator>::IntoIter

impl<'a, A> IntoIterator for &'a Vector<A> where
    A: Clone, 

type Item = &'a A

type IntoIter = Iter<'a, A>

pub fn into_iter(self) -> <&'a Vector<A> as IntoIterator>::IntoIter

impl<'a, K, V, S> IntoIterator for &'a HashMap<K, V, S> where
    S: BuildHasher,
    K: Hash + Eq, 

type Item = (&'a K, &'a V)

type IntoIter = Iter<'a, K, V>

pub fn into_iter(self) -> <&'a HashMap<K, V, S> as IntoIterator>::IntoIter

impl<'a, A> IntoIterator for FocusMut<'a, A> where
    A: Clone + 'a, 

type Item = &'a mut A

type IntoIter = IterMut<'a, A>

pub fn into_iter(self) -> <FocusMut<'a, A> as IntoIterator>::IntoIter

impl<'a, K, V> IntoIterator for &'a OrdMap<K, V> where
    K: Ord, 

type Item = (&'a K, &'a V)

type IntoIter = Iter<'a, K, V>

pub fn into_iter(self) -> <&'a OrdMap<K, V> as IntoIterator>::IntoIter

impl<A, S> IntoIterator for HashSet<A, S> where
    A: Hash + Eq + Clone,
    S: BuildHasher, 

type Item = A

type IntoIter = ConsumingIter<<HashSet<A, S> as IntoIterator>::Item>

pub fn into_iter(self) -> <HashSet<A, S> as IntoIterator>::IntoIter

impl<'a, A> IntoIterator for &'a OrdSet<A> where
    A: 'a + Ord, 

type Item = &'a A

type IntoIter = Iter<'a, A>

pub fn into_iter(self) -> <&'a OrdSet<A> as IntoIterator>::IntoIter

impl<K, V, S> IntoIterator for HashMap<K, V, S> where
    V: Clone,
    S: BuildHasher,
    K: Hash + Eq + Clone, 

type Item = (K, V)

type IntoIter = ConsumingIter<(K, V)>

pub fn into_iter(self) -> <HashMap<K, V, S> as IntoIterator>::IntoIter

impl<'a, A> IntoIterator for Focus<'a, A> where
    A: Clone + 'a, 

type Item = &'a A

type IntoIter = Iter<'a, A>

pub fn into_iter(self) -> <Focus<'a, A> as IntoIterator>::IntoIter

impl<'a, A, N> IntoIterator for &'a Chunk<A, N> where
    N: ChunkLength<A>, 

type Item = &'a A

type IntoIter = Iter<'a, A>

pub fn into_iter(self) -> <&'a Chunk<A, N> as IntoIterator>::IntoIter

impl<'a, A, N> IntoIterator for &'a mut Chunk<A, N> where
    N: ChunkLength<A>, 

type Item = &'a mut A

type IntoIter = IterMut<'a, A>

pub fn into_iter(self) -> <&'a mut Chunk<A, N> as IntoIterator>::IntoIter

impl<A, T> IntoIterator for InlineArray<A, T>

type Item = A

type IntoIter = Iter<A, T>

pub fn into_iter(self) -> <InlineArray<A, T> as IntoIterator>::IntoIter

impl<A, N> IntoIterator for SparseChunk<A, N> where
    N: ChunkLength<A> + Bits, 

type Item = A

type IntoIter = Drain<A, N>

pub fn into_iter(self) -> <SparseChunk<A, N> as IntoIterator>::IntoIter

impl<'a, A, T> IntoIterator for &'a mut InlineArray<A, T>

type Item = &'a mut A

type IntoIter = IterMut<'a, A>

pub fn into_iter(self) -> <&'a mut InlineArray<A, T> as IntoIterator>::IntoIter

impl<A, N> IntoIterator for Chunk<A, N> where
    N: ChunkLength<A>, 

type Item = A

type IntoIter = Iter<A, N>

pub fn into_iter(self) -> <Chunk<A, N> as IntoIterator>::IntoIter

impl<'a, A, T> IntoIterator for &'a InlineArray<A, T>

type Item = &'a A

type IntoIter = Iter<'a, A>

pub fn into_iter(self) -> <&'a InlineArray<A, T> as IntoIterator>::IntoIter

impl<'a, Size> IntoIterator for &'a Bitmap<Size> where
    Size: Bits, 

type Item = usize

type IntoIter = Iter<'a, Size>

pub fn into_iter(self) -> <&'a Bitmap<Size> as IntoIterator>::IntoIter

impl<'a, T> IntoIterator for &'a mut Arena<T>

type Item = (usize, &'a mut T)

type IntoIter = IterMut<'a, T>

pub fn into_iter(self) -> <&'a mut Arena<T> as IntoIterator>::IntoIter

impl<T> IntoIterator for Arena<T>

type Item = (usize, T)

type IntoIter = IntoIter<T>

pub fn into_iter(self) -> <Arena<T> as IntoIterator>::IntoIter

impl<'a, T> IntoIterator for &'a Arena<T>

type Item = (usize, &'a T)

type IntoIter = Iter<'a, T>

pub fn into_iter(self) -> <&'a Arena<T> as IntoIterator>::IntoIter

impl<'a> IntoIterator for &'a Events

type Item = &'a Event

type IntoIter = Iter<'a>

pub fn into_iter(self) -> <&'a Events as IntoIterator>::IntoIter

impl<'a, T> IntoIterator for &'a mut Stack<T> where
    T: Stackable, 

type Item = &'a mut <T as ForeignType>::Ref

type IntoIter = IterMut<'a, T>

pub fn into_iter(self) -> IterMut<'a, T>

impl<'a, T> IntoIterator for &'a mut StackRef<T> where
    T: Stackable, 

type Item = &'a mut <T as ForeignType>::Ref

type IntoIter = IterMut<'a, T>

pub fn into_iter(self) -> IterMut<'a, T>

impl<T> IntoIterator for Stack<T> where
    T: Stackable, 

type IntoIter = IntoIter<T>

type Item = T

pub fn into_iter(self) -> IntoIter<T>

impl<'a, T> IntoIterator for &'a Stack<T> where
    T: Stackable, 

type Item = &'a <T as ForeignType>::Ref

type IntoIter = Iter<'a, T>

pub fn into_iter(self) -> Iter<'a, T>

impl<'a, T> IntoIterator for &'a StackRef<T> where
    T: Stackable, 

type Item = &'a <T as ForeignType>::Ref

type IntoIter = Iter<'a, T>

pub fn into_iter(self) -> Iter<'a, T>

impl<'a, T> IntoIterator for &'a mut Slab<T>

type Item = (usize, &'a mut T)

type IntoIter = IterMut<'a, T>

pub fn into_iter(self) -> IterMut<'a, T>

impl<'a, T> IntoIterator for &'a Slab<T>

type Item = (usize, &'a T)

type IntoIter = Iter<'a, T>

pub fn into_iter(self) -> Iter<'a, T>

impl<'a, K, V> IntoIterator for &'a Map<K, V>

type Item = (&'a K, &'a V)

type IntoIter = Entries<'a, K, V>

pub fn into_iter(self) -> Entries<'a, K, V>

impl<'a, T> IntoIterator for &'a Set<T>

type Item = &'a T

type IntoIter = Iter<'a, T>

pub fn into_iter(self) -> Iter<'a, T>

impl<T> IntoIterator for Values<T>

type Item = <Vec<T, Global> as IntoIterator>::Item

type IntoIter = <Vec<T, Global> as IntoIterator>::IntoIter

pub fn into_iter(self) -> <Values<T> as IntoIterator>::IntoIter

impl<'a, T> IntoIterator for &'a mut Values<T>

type Item = <&'a mut Vec<T, Global> as IntoIterator>::Item

type IntoIter = <&'a mut Vec<T, Global> as IntoIterator>::IntoIter

pub fn into_iter(self) -> <&'a mut Values<T> as IntoIterator>::IntoIter

impl<'a, T> IntoIterator for &'a Values<T>

type Item = <&'a Vec<T, Global> as IntoIterator>::Item

type IntoIter = <&'a Vec<T, Global> as IntoIterator>::IntoIter

pub fn into_iter(self) -> <&'a Values<T> as IntoIterator>::IntoIter

impl<'a, T> IntoIterator for &'a mut HeaderMap<T>

type Item = (&'a HeaderName, &'a mut T)

type IntoIter = IterMut<'a, T>

pub fn into_iter(self) -> IterMut<'a, T>

impl<'a, T> IntoIterator for &'a HeaderMap<T>

type Item = (&'a HeaderName, &'a T)

type IntoIter = Iter<'a, T>

pub fn into_iter(self) -> Iter<'a, T>

impl<'a, T> IntoIterator for OccupiedEntry<'a, T>

type Item = &'a mut T

type IntoIter = ValueIterMut<'a, T>

pub fn into_iter(self) -> ValueIterMut<'a, T>

impl<'a, T> IntoIterator for GetAll<'a, T>

type Item = &'a T

type IntoIter = ValueIter<'a, T>

pub fn into_iter(self) -> ValueIter<'a, T>

impl<'a, 'b, T> IntoIterator for &'b GetAll<'a, T> where
    'b: 'a, 

type Item = &'a T

type IntoIter = ValueIter<'a, T>

pub fn into_iter(self) -> ValueIter<'a, T>

impl<'a, 'b, T> IntoIterator for &'b mut OccupiedEntry<'a, T> where
    'b: 'a, 

type Item = &'a mut T

type IntoIter = ValueIterMut<'a, T>

pub fn into_iter(self) -> ValueIterMut<'a, T>

impl<'a, 'b, T> IntoIterator for &'b OccupiedEntry<'a, T> where
    'b: 'a, 

type Item = &'a T

type IntoIter = ValueIter<'a, T>

pub fn into_iter(self) -> ValueIter<'a, T>

impl<T> IntoIterator for HeaderMap<T>

type Item = (Option<HeaderName>, T)

type IntoIter = IntoIter<T>

pub fn into_iter(self) -> IntoIter<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());

impl IntoIterator for BytesMut

type Item = u8

type IntoIter = IntoIter<BytesMut>

pub fn into_iter(self) -> <BytesMut as IntoIterator>::IntoIter

impl IntoIterator for Bytes

type Item = u8

type IntoIter = IntoIter<Bytes>

pub fn into_iter(self) -> <Bytes as IntoIterator>::IntoIter

impl<T, U> IntoIterator for Chain<T, U> where
    T: Buf,
    U: Buf, 

type Item = u8

type IntoIter = IntoIter<Chain<T, U>>

pub fn into_iter(self) -> <Chain<T, U> as IntoIterator>::IntoIter

impl<'a> IntoIterator for &'a Bytes

type Item = &'a u8

type IntoIter = Iter<'a, u8>

pub fn into_iter(self) -> <&'a Bytes as IntoIterator>::IntoIter

impl<'a> IntoIterator for &'a BytesMut

type Item = &'a u8

type IntoIter = Iter<'a, u8>

pub fn into_iter(self) -> <&'a BytesMut as IntoIterator>::IntoIter

impl IntoIterator for Events

type Item = Event

type IntoIter = IntoIter

pub fn into_iter(self) -> <Events as IntoIterator>::IntoIter

impl<'a> IntoIterator for &'a Events

type Item = Event

type IntoIter = Iter<'a>

pub fn into_iter(self) -> <&'a Events as IntoIterator>::IntoIter

impl<'a> IntoIterator for &'a FieldSet

type IntoIter = Iter

type Item = Field

pub fn into_iter(self) -> <&'a FieldSet as IntoIterator>::IntoIter

impl<'a, T, S> IntoIterator for &'a IndexSet<T, S>

type Item = &'a T

type IntoIter = Iter<'a, T>

pub fn into_iter(self) -> <&'a IndexSet<T, S> as IntoIterator>::IntoIter

impl<'a, K, V, S> IntoIterator for &'a mut IndexMap<K, V, S>

type Item = (&'a K, &'a mut V)

type IntoIter = IterMut<'a, K, V>

pub fn into_iter(self) -> <&'a mut IndexMap<K, V, S> as IntoIterator>::IntoIter

impl<'a, K, V, S> IntoIterator for &'a IndexMap<K, V, S>

type Item = (&'a K, &'a V)

type IntoIter = Iter<'a, K, V>

pub fn into_iter(self) -> <&'a IndexMap<K, V, S> as IntoIterator>::IntoIter

impl<K, V, S> IntoIterator for IndexMap<K, V, S>

type Item = (K, V)

type IntoIter = IntoIter<K, V>

pub fn into_iter(self) -> <IndexMap<K, V, S> as IntoIterator>::IntoIter

impl<T, S> IntoIterator for IndexSet<T, S>

type Item = T

type IntoIter = IntoIter<T>

pub fn into_iter(self) -> <IndexSet<T, S> as IntoIterator>::IntoIter

impl<'a, T, S> IntoIterator for &'a HashSet<T, S>

type Item = &'a T

type IntoIter = Iter<'a, T>

pub fn into_iter(self) -> Iter<'a, T>

impl<'a, K, V, S> IntoIterator for &'a HashMap<K, V, S>

type Item = (&'a K, &'a V)

type IntoIter = Iter<'a, K, V>

pub fn into_iter(self) -> Iter<'a, K, V>

impl<'a, K, V, S> IntoIterator for &'a mut HashMap<K, V, S>

type Item = (&'a K, &'a mut V)

type IntoIter = IterMut<'a, K, V>

pub fn into_iter(self) -> IterMut<'a, K, V>

impl<T, S> IntoIterator for HashSet<T, S>

type Item = T

type IntoIter = IntoIter<T>

pub fn into_iter(self) -> IntoIter<T>

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);
}

impl<T> IntoIterator for RawTable<T>

type Item = T

type IntoIter = RawIntoIter<T>

pub fn into_iter(self) -> RawIntoIter<T>

impl<K, V, S> IntoIterator for HashMap<K, V, S>

type Item = (K, V)

type IntoIter = IntoIter<K, V>

pub fn into_iter(self) -> IntoIter<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();

impl IntoIterator for MimeGuess

type Item = Mime

type IntoIter = Iter

pub fn into_iter(self) -> <MimeGuess as IntoIterator>::IntoIter

impl<'a> IntoIterator for &'a MimeGuess

type Item = Mime

type IntoIter = Iter

pub fn into_iter(self) -> <&'a MimeGuess as IntoIterator>::IntoIter

Loading content...

Implementors

impl IntoIterator for af_lib::prelude::af_core::test::prelude::json::Map<String, Value>

type Item = (String, Value)

type IntoIter = IntoIter

pub fn into_iter(self) -> <Map<String, Value> as IntoIterator>::IntoIter

impl<'a> IntoIterator for &'a af_lib::prelude::af_core::test::prelude::json::Map<String, Value>

type Item = (&'a String, &'a Value)

type IntoIter = Iter<'a>

pub fn into_iter(self) -> <&'a Map<String, Value> as IntoIterator>::IntoIter

impl<'a> IntoIterator for &'a mut af_lib::prelude::af_core::test::prelude::json::Map<String, Value>

type Item = (&'a String, &'a mut Value)

type IntoIter = IterMut<'a>

pub fn into_iter(self) -> <&'a mut Map<String, Value> as IntoIterator>::IntoIter

impl<'a, I> IntoIterator for &'a IntoChunks<I> where
    I: Iterator,
    <I as Iterator>::Item: 'a, 

type Item = Chunk<'a, I>

type IntoIter = Chunks<'a, I>

pub fn into_iter(self) -> <&'a IntoChunks<I> as IntoIterator>::IntoIter

impl<'a, I> IntoIterator for &'a RcIter<I> where
    I: Iterator, 

Return an iterator from &RcIter<I> (by simply cloning it).

type Item = <I as Iterator>::Item

type IntoIter = RcIter<I>

pub fn into_iter(self) -> RcIter<I>

impl<'a, K, I, F> IntoIterator for &'a GroupBy<K, I, F> where
    F: FnMut(&<I as Iterator>::Item) -> K,
    I: Iterator,
    K: PartialEq<K>,
    <I as Iterator>::Item: 'a, 

type Item = (K, Group<'a, K, I, F>)

type IntoIter = Groups<'a, K, I, F>

pub fn into_iter(self) -> <&'a GroupBy<K, I, F> as IntoIterator>::IntoIter

impl<I> IntoIterator for I where
    I: Iterator, 

type Item = <I as Iterator>::Item

type IntoIter = I

pub fn into_iter(self) -> I

Loading content...