Trait gclient::ext::sp_core::sp_std::iter::IntoIterator

pub trait IntoIterator {
    type Item;
    type IntoIter: Iterator<Item = Self::Item>;

    // Required method
    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 = [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()
}

Required Associated Types

type Item

The type of the elements being iterated over.

type IntoIter: Iterator<Item = Self::Item>

Which kind of iterator are we turning this into?

Required Methods

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

See the module-level documentation for more.

Examples

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

Implementors

impl IntoIterator for IndexVec

type Item = usize

type IntoIter = IndexVecIntoIter

impl IntoIterator for Justifications

type Item = ([u8; 4], Vec<u8>)

type IntoIter = IntoIter<<Justifications as IntoIterator>::Item>

impl IntoIterator for Map<String, Value>

type Item = (String, Value)

type IntoIter = IntoIter

impl IntoIterator for Targets

type Item = (String, LevelFilter)

type IntoIter = IntoIter

impl IntoIterator for Access

type Item = Access

type IntoIter = Iter<Access>

impl IntoIterator for AtFlags

type Item = AtFlags

type IntoIter = Iter<AtFlags>

impl IntoIterator for Bits

type Item = bool

type IntoIter = BitsIntoIter

impl IntoIterator for Bytes

type Item = u8

type IntoIter = IntoIter<Bytes>

impl IntoIterator for BytesMut

type Item = u8

type IntoIter = IntoIter<BytesMut>

impl IntoIterator for ControlModes

type Item = ControlModes

type IntoIter = Iter<ControlModes>

impl IntoIterator for CreateFlags

type Item = CreateFlags

type IntoIter = Iter<CreateFlags>

impl IntoIterator for DupFlags

type Item = DupFlags

type IntoIter = Iter<DupFlags>

impl IntoIterator for FallocateFlags

type Item = FallocateFlags

type IntoIter = Iter<FallocateFlags>

impl IntoIterator for FdFlags

type Item = FdFlags

type IntoIter = Iter<FdFlags>

impl IntoIterator for IFlags

type Item = IFlags

type IntoIter = Iter<IFlags>

impl IntoIterator for InputModes

type Item = InputModes

type IntoIter = Iter<InputModes>

impl IntoIterator for LocalModes

type Item = LocalModes

type IntoIter = Iter<LocalModes>

impl IntoIterator for MemfdFlags

type Item = MemfdFlags

type IntoIter = Iter<MemfdFlags>

impl IntoIterator for Mode

type Item = Mode

type IntoIter = Iter<Mode>

impl IntoIterator for MountFlags

type Item = MountFlags

type IntoIter = Iter<MountFlags>

impl IntoIterator for MountPropagationFlags

type Item = MountPropagationFlags

type IntoIter = Iter<MountPropagationFlags>

impl IntoIterator for OFlags

type Item = OFlags

type IntoIter = Iter<OFlags>

impl IntoIterator for OutputModes

type Item = OutputModes

type IntoIter = Iter<OutputModes>

impl IntoIterator for ReadWriteFlags

type Item = ReadWriteFlags

type IntoIter = Iter<ReadWriteFlags>

impl IntoIterator for RenameFlags

type Item = RenameFlags

type IntoIter = Iter<RenameFlags>

impl IntoIterator for ResolveFlags

type Item = ResolveFlags

type IntoIter = Iter<ResolveFlags>

impl IntoIterator for SealFlags

type Item = SealFlags

type IntoIter = Iter<SealFlags>

impl IntoIterator for SerializedSignature

type IntoIter = IntoIter

type Item = u8

impl IntoIterator for SetMatches

type IntoIter = SetMatchesIntoIter

type Item = usize

impl IntoIterator for SetMatches

type IntoIter = SetMatchesIntoIter

type Item = usize

impl IntoIterator for StatVfsMountFlags

type Item = StatVfsMountFlags

type IntoIter = Iter<StatVfsMountFlags>

impl IntoIterator for StatxFlags

type Item = StatxFlags

type IntoIter = Iter<StatxFlags>

impl IntoIterator for UnmountFlags

type Item = UnmountFlags

type IntoIter = Iter<UnmountFlags>

impl IntoIterator for WatchFlags

type Item = WatchFlags

type IntoIter = Iter<WatchFlags>

impl IntoIterator for XattrFlags

type Item = XattrFlags

type IntoIter = Iter<XattrFlags>

impl<'a> IntoIterator for &'a UnixListener

type Item = Result<UnixStream, Error>

type IntoIter = Incoming<'a>

impl<'a> IntoIterator for &'a Path

type Item = &'a OsStr

type IntoIter = Iter<'a>

impl<'a> IntoIterator for &'a PathBuf

type Item = &'a OsStr

type IntoIter = Iter<'a>

impl<'a> IntoIterator for &'a Map<String, Value>

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

type IntoIter = Iter<'a>

impl<'a> IntoIterator for &'a Targets

type Item = (&'a str, LevelFilter)

type IntoIter = Iter<'a>

impl<'a> IntoIterator for &'a BorrowedCertRevocationList<'a>

type Item = Result<BorrowedRevokedCert<'a>, Error>

type IntoIter = RevokedCerts<'a>

impl<'a> IntoIterator for &'a Bytes

type Item = &'a u8

type IntoIter = Iter<'a, u8>

impl<'a> IntoIterator for &'a BytesMut

type Item = &'a u8

type IntoIter = Iter<'a, u8>

impl<'a> IntoIterator for &'a EventVec

type IntoIter = Iter<'a>

type Item = (EventFlags, u64)

impl<'a> IntoIterator for &'a Events

type Item = &'a Event

type IntoIter = Iter<'a>

impl<'a> IntoIterator for &'a FieldSet

type IntoIter = Iter

type Item = Field

impl<'a> IntoIterator for &'a SerializedSignature

type IntoIter = Iter<'a, u8>

type Item = &'a u8

impl<'a> IntoIterator for &'a SetMatches

type IntoIter = SetMatchesIter<'a>

type Item = usize

impl<'a> IntoIterator for &'a SetMatches

type IntoIter = SetMatchesIter<'a>

type Item = usize

impl<'a> IntoIterator for &'a Utf8Sequence

type IntoIter = Iter<'a, Utf8Range>

type Item = &'a Utf8Range

impl<'a> IntoIterator for &'a Utf8Sequence

type IntoIter = Iter<'a, Utf8Range>

type Item = &'a Utf8Range

impl<'a> IntoIterator for &'a mut Map<String, Value>

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

type IntoIter = IterMut<'a>

impl<'a> IntoIterator for BatchRequestBuilder<'a>

type Item = (&'a str, Option<Box<RawValue>>)

type IntoIter = IntoIter<<BatchRequestBuilder<'a> as IntoIterator>::Item>

impl<'a> IntoIterator for BatchRequestBuilder<'a>

type Item = (&'a str, Option<Box<RawValue>>)

type IntoIter = IntoIter<<BatchRequestBuilder<'a> as IntoIterator>::Item>

impl<'a> IntoIterator for LocalsReader<'a>

type Item = Result<(u32, ValType), BinaryReaderError>

type IntoIter = LocalsIterator<'a>

impl<'a> IntoIterator for LocalsReader<'a>

type Item = Result<(u32, ValType), BinaryReaderError>

type IntoIter = LocalsIterator<'a>

impl<'a> IntoIterator for OperatorsReader<'a>

type Item = Result<Operator<'a>, BinaryReaderError>

type IntoIter = OperatorsIterator<'a>

impl<'a> IntoIterator for OperatorsReader<'a>

type Item = Result<Operator<'a>, BinaryReaderError>

type IntoIter = OperatorsIterator<'a>

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

where 'b: 'a,

type Item = &'a T

type IntoIter = ValueIter<'a, T>

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

where 'b: 'a,

type Item = &'a T

type IntoIter = 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>

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

where A: Array,

Iterate the ArrayVec with references to each element.

use arrayvec::ArrayVec;

let array = ArrayVec::from([1, 2, 3]);

for elt in &array {
    // ...
}

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

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

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

where A: Array,

Iterate the ArrayVec with references to each element.

use arrayvec::ArrayVec;

let array = ArrayVec::from([1, 2, 3]);

for elt in &array {
    // ...
}

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

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

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>

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

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>

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

where A: Array,

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 {
    // ...
}

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

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

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

where A: Array,

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 {
    // ...
}

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

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

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>

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

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>

impl<'a, A, O> IntoIterator for &'a BitArray<A, O>

where O: BitOrder, A: 'a + BitViewSized,

Original

type IntoIter = <&'a BitSlice<<A as BitView>::Store, O> as IntoIterator>::IntoIter

type Item = <&'a BitSlice<<A as BitView>::Store, O> as IntoIterator>::Item

impl<'a, A, O> IntoIterator for &'a mut BitArray<A, O>

where O: BitOrder, A: 'a + BitViewSized,

Original

type IntoIter = <&'a mut BitSlice<<A as BitView>::Store, O> as IntoIterator>::IntoIter

type Item = <&'a mut BitSlice<<A as BitView>::Store, O> as IntoIterator>::Item

impl<'a, Fut> IntoIterator for &'a FuturesUnordered<Fut>

where Fut: Unpin,

type Item = &'a Fut

type IntoIter = Iter<'a, Fut>

impl<'a, Fut> IntoIterator for &'a mut FuturesUnordered<Fut>

where Fut: Unpin,

type Item = &'a mut Fut

type IntoIter = IterMut<'a, Fut>

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

where K: EntityRef,

type Item = (K, &'a V)

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

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

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

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

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

where K: EntityRef,

type Item = (K, &'a V)

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

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

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

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

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

where K: EntityRef, V: SparseMapValue<K>,

Iterating over the elements of a set.

type Item = &'a V

type IntoIter = Iter<'a, V>

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

where K: EntityRef,

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

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

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

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

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

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

where K: EntityRef,

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

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

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

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

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

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

where A: Allocator + Clone,

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

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

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

where A: Allocator + Clone,

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

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

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

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

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

impl<'a, K, V, S> IntoIterator for &'a std::collections::hash::map::HashMap<K, V, S>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<'a, K, V, S> IntoIterator for &'a mut std::collections::hash::map::HashMap<K, V, S>

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

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

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

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

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

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

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

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

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>

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

where A: Allocator + Clone,

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

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

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

where A: Allocator + Clone,

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

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

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

where A: Allocator,

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

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

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

where A: Allocator + Clone,

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

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

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

where A: Allocator + Clone,

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

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

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

where A: Allocator,

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

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

impl<'a, R> IntoIterator for BatchResponse<'a, R>

type Item = Result<R, ErrorObject<'a>>

type IntoIter = IntoIter<<BatchResponse<'a, R> as IntoIterator>::Item>

impl<'a, R> IntoIterator for BatchResponse<'a, R>

type Item = Result<R, ErrorObject<'a>>

type IntoIter = IntoIter<<BatchResponse<'a, R> as IntoIterator>::Item>

impl<'a, St> IntoIterator for &'a SelectAll<St>

where St: Stream + Unpin,

type Item = &'a St

type IntoIter = Iter<'a, St>

impl<'a, St> IntoIterator for &'a mut SelectAll<St>

where St: Stream + Unpin,

type Item = &'a mut St

type IntoIter = IterMut<'a, St>

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

type Item = &'a T

type IntoIter = Iter<'a, T>

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

type Item = &'a T

type IntoIter = Iter<'a, T>

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

type Item = T

type IntoIter = Iter<'a, T>

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

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

type IntoIter = Iter<'a, T>

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

where T: 'static,

type Item = (u32, &'a T)

type IntoIter = Iter<'a, T>

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

where T: 'static,

type Item = (u32, &'a T)

type IntoIter = Iter<'a, T>

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

type Item = &'a T

type IntoIter = Iter<'a, T>

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

type Item = &'a T

type IntoIter = Chain<Once<&'a T>, Iter<'a, T>>

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

type Item = (usize, &'a T)

type IntoIter = Iter<'a, T>

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

type IntoIter = Iter<'a, T>

type Item = &'a T

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

where T: Send + Sync,

type Item = &'a T

type IntoIter = Iter<'a, T>

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

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

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

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

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

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

type IntoIter = IterMut<'a, T>

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

where T: Send + 'a,

type Item = &'a mut T

type IntoIter = CachedIterMut<'a, T>

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

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

type IntoIter = IterMut<'a, T>

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

where T: Send,

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

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

type Item = &'a T

type IntoIter = ValueIter<'a, T>

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

type Item = &'a mut T

type IntoIter = ValueIterMut<'a, T>

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

where T: FromReader<'a>,

type Item = Result<T, BinaryReaderError>

type IntoIter = SectionLimitedIntoIter<'a, T>

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

where T: FromReader<'a>,

type Item = Result<T, BinaryReaderError>

type IntoIter = SectionLimitedIntoIter<'a, T>

impl<'a, T, A> IntoIterator for &'a gclient::ext::sp_runtime::app_crypto::Vec<T, A>

where A: Allocator,

type Item = &'a T

type IntoIter = Iter<'a, T>

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

where A: Allocator + Clone,

type Item = &'a T

type IntoIter = Iter<'a, T>

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

where A: Allocator,

type Item = &'a T

type IntoIter = Iter<'a, T>

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

where A: Allocator,

type Item = &'a T

type IntoIter = Iter<'a, T>

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

where A: Allocator,

type Item = &'a T

type IntoIter = Iter<'a, T>

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

where A: Allocator,

type Item = &'a T

type IntoIter = Iter<'a, T>

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

where A: Allocator,

type Item = &'a T

type IntoIter = Iter<'a, T>

impl<'a, T, A> IntoIterator for &'a mut gclient::ext::sp_runtime::app_crypto::Vec<T, A>

where A: Allocator,

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

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

where A: Allocator,

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

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

where A: Allocator,

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

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

where A: Allocator,

type Item = &'a mut T

type IntoIter = IterMut<'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>

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

type Item = &'a T

type IntoIter = Iter<'a, T>

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

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

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

where T: 'a, N: ArrayLength<T>,

type IntoIter = Iter<'a, T>

type Item = &'a T

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

where T: 'a, N: ArrayLength<T>,

type IntoIter = Iter<'a, T>

type Item = &'a T

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

where T: 'a, N: ArrayLength<T>,

type IntoIter = IterMut<'a, T>

type Item = &'a mut T

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

where T: 'a, N: ArrayLength<T>,

type IntoIter = IterMut<'a, T>

type Item = &'a mut T

impl<'a, T, O> IntoIterator for &'a BitSlice<T, O>

where T: 'a + BitStore, O: BitOrder,

Original

type IntoIter = Iter<'a, T, O>

type Item = <<&'a BitSlice<T, O> as IntoIterator>::IntoIter as Iterator>::Item

impl<'a, T, O> IntoIterator for &'a BitVec<T, O>

where O: BitOrder, T: 'a + BitStore,

Original

type IntoIter = <&'a BitSlice<T, O> as IntoIterator>::IntoIter

type Item = <&'a BitSlice<T, O> as IntoIterator>::Item

impl<'a, T, O> IntoIterator for &'a mut BitSlice<T, O>

where T: 'a + BitStore, O: BitOrder,

Original

type IntoIter = IterMut<'a, T, O>

type Item = <<&'a mut BitSlice<T, O> as IntoIterator>::IntoIter as Iterator>::Item

impl<'a, T, O> IntoIterator for &'a mut BitVec<T, O>

where O: BitOrder, T: 'a + BitStore,

Original

type IntoIter = <&'a mut BitSlice<T, O> as IntoIterator>::IntoIter

type Item = <&'a mut BitSlice<T, O> as IntoIterator>::Item

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

type Item = &'a T

type IntoIter = Iter<'a, T>

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

type Item = &'a T

type IntoIter = Iter<'a, T>

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

type Item = &'a T

type IntoIter = Iter<'a, T>

impl<'a, T, S> IntoIterator for &'a std::collections::hash::set::HashSet<T, S>

type Item = &'a T

type IntoIter = Iter<'a, T>

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

type Item = &'a T

type IntoIter = Iter<'a, T>

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

type Item = &'a T

type IntoIter = Iter<'a, T>

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

type Item = &'a T

type IntoIter = Iter<'a, T>

impl<'a, T, S> IntoIterator for &'a mut BoundedVec<T, S>

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

impl<'a, T, S> IntoIterator for &'a mut WeakBoundedVec<T, S>

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

impl<'a, T, S> IntoIterator for BoundedSlice<'a, T, S>

type Item = &'a T

type IntoIter = Iter<'a, T>

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

where A: Allocator + Clone,

type Item = &'a T

type IntoIter = Iter<'a, T>

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

where A: Allocator + Clone,

type Item = &'a T

type IntoIter = Iter<'a, T>

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

where A: Allocator,

type Item = &'a T

type IntoIter = Iter<'a, T>

impl<'a, T, const CAP: usize> IntoIterator for &'a arrayvec::arrayvec::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 {
    // ...
}

type Item = &'a T

type IntoIter = Iter<'a, T>

impl<'a, T, const CAP: usize> IntoIterator for &'a mut arrayvec::arrayvec::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 {
    // ...
}

type Item = &'a mut T

type IntoIter = IterMut<'a, T>

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

type Item = &'a T

type IntoIter = 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>

impl<'context, Context> IntoIterator for &'context EventVec<'context, Context>

where Context: Context,

type IntoIter = Iter<'context, Context>

type Item = (EventFlags, Ref<'context, <Context as Context>::Target>)

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

type Item = &'s mut T

type IntoIter = IterMut<'s, T>

impl<A> IntoIterator for arrayvec::ArrayVec<A>

where A: Array,

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]) {
    // ...
}

type Item = <A as Array>::Item

type IntoIter = IntoIter<A>

impl<A> IntoIterator for arrayvec::ArrayVec<A>

where A: Array,

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]) {
    // ...
}

type Item = <A as Array>::Item

type IntoIter = IntoIter<A>

impl<A> IntoIterator for ArrayVec<A>

where A: Array,

type Item = <A as Array>::Item

type IntoIter = ArrayVecIterator<A>

impl<A> IntoIterator for SmallVec<A>

where A: Array,

type IntoIter = IntoIter<A>

type Item = <A as Array>::Item

impl<A> IntoIterator for TinyVec<A>

where A: Array,

type Item = <A as Array>::Item

type IntoIter = TinyVecIterator<A>

impl<A, O> IntoIterator for BitArray<A, O>

where A: BitViewSized, O: BitOrder,

Original

type IntoIter = IntoIter<A, O>

type Item = <IntoIter<A, O> as Iterator>::Item

impl<Fut> IntoIterator for FuturesUnordered<Fut>

where Fut: Unpin,

type Item = Fut

type IntoIter = IntoIter<Fut>

impl<I> IntoIterator for I

where I: Iterator,

type Item = <I as Iterator>::Item

type IntoIter = I

impl<K, V> IntoIterator for Box<Slice<K, V>>

type IntoIter = IntoIter<K, V>

type Item = (K, V)

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

type Item = (K, V)

type IntoIter = IntoIter<K, V>

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

where K: EntityRef,

type Item = (K, V)

type IntoIter = IntoIter<K, V>

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

where A: Allocator + Clone,

type Item = (K, V)

type IntoIter = IntoIter<K, V, A>

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

type Item = (K, V)

type IntoIter = IntoIter<K, V>

impl<K, V, S> IntoIterator for std::collections::hash::map::HashMap<K, V, S>

type Item = (K, V)

type IntoIter = IntoIter<K, V>

impl<K, V, S> IntoIterator for indexmap::map::IndexMap<K, V, S>

type Item = (K, V)

type IntoIter = IntoIter<K, V>

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

type Item = (K, V)

type IntoIter = IntoIter<K, V>

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

type Item = (K, V)

type IntoIter = IntoIter<K, V>

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

where A: Allocator + Clone,

type Item = (K, V)

type IntoIter = IntoIter<K, V, A>

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

where A: Allocator + Clone,

type Item = (K, V)

type IntoIter = IntoIter<K, V, A>

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

where A: Allocator,

type Item = (K, V)

type IntoIter = IntoIter<K, V, A>

impl<St> IntoIterator for SelectAll<St>

where St: Stream + Unpin,

type Item = St

type IntoIter = IntoIter<St>

impl<T> IntoIterator for Option<T>

type Item = T

type IntoIter = IntoIter<T>

impl<T> IntoIterator for Box<Slice<T>>

type IntoIter = IntoIter<T>

type Item = T

impl<T> IntoIterator for Receiver<T>

type Item = T

type IntoIter = IntoIter<T>

impl<T> IntoIterator for HeaderMap<T>

type Item = (Option<HeaderName>, T)

type IntoIter = IntoIter<T>

impl<T> IntoIterator for CachedThreadLocal<T>

where T: Send,

type Item = T

type IntoIter = CachedIntoIter<T>

impl<T> IntoIterator for IndexMap<T>

type Item = (u32, T)

type IntoIter = IntoIter<T>

impl<T> IntoIterator for IndexMap<T>

type Item = (u32, T)

type IntoIter = IntoIter<T>

impl<T> IntoIterator for IndexSet<T>

type Item = T

type IntoIter = IntoIter<T>

impl<T> IntoIterator for NonEmpty<T>

type Item = T

type IntoIter = Chain<Once<T>, IntoIter<<NonEmpty<T> as IntoIterator>::Item>>

impl<T> IntoIterator for Slab<T>

type Item = (usize, T)

type IntoIter = IntoIter<T>

impl<T> IntoIterator for ThreadLocal<T>

where T: Send,

type Item = T

type IntoIter = IntoIter<T>

impl<T, A> IntoIterator for gclient::ext::sp_runtime::app_crypto::Vec<T, A>

where A: Allocator,

type Item = T

type IntoIter = IntoIter<T, A>

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

where A: Allocator + Clone,

type Item = T

type IntoIter = IntoIter<T, A>

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

where A: Allocator,

type Item = T

type IntoIter = IntoIter<T, A>

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

where A: Allocator,

type Item = T

type IntoIter = IntoIter<T, A>

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

where A: Allocator,

type Item = T

type IntoIter = IntoIter<T, A>

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

where A: Allocator,

type Item = T

type IntoIter = IntoIter<T, A>

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

where A: Allocator + Clone,

type Item = T

type IntoIter = RawIntoIter<T, A>

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

where A: Allocator + Clone,

type Item = T

type IntoIter = RawIntoIter<T, A>

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

where A: Allocator,

type Item = T

type IntoIter = RawIntoIter<T, A>

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

where A: Allocator,

type Item = T

type IntoIter = IntoIter<T, A>

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

type Item = T

type IntoIter = IntoIter<T>

impl<T, N> IntoIterator for GenericArray<T, N>

where N: ArrayLength<T>,

type Item = T

type IntoIter = GenericArrayIter<T, N>

impl<T, N> IntoIterator for GenericArray<T, N>

where N: ArrayLength<T>,

type Item = T

type IntoIter = GenericArrayIter<T, N>

impl<T, O> IntoIterator for BitBox<T, O>

where T: BitStore, O: BitOrder,

Original

type IntoIter = IntoIter<T, O>

type Item = bool

impl<T, O> IntoIterator for BitVec<T, O>

where T: BitStore, O: BitOrder,

Bit-Vector Iteration

Bit-vectors have the advantage that iteration consumes the whole structure, so they can simply freeze the allocation into a bit-box, then use its iteration and destructor.

Original

impl<T> IntoIterator for Vec<T>

type IntoIter = <BitBox<T, O> as IntoIterator>::IntoIter

type Item = <BitBox<T, O> as IntoIterator>::Item

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

type Item = T

type IntoIter = IntoIter<T>

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

type Item = T

type IntoIter = IntoIter<T>

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

type Item = T

type IntoIter = IntoIter<T>

impl<T, S> IntoIterator for std::collections::hash::set::HashSet<T, S>

type Item = T

type IntoIter = IntoIter<T>

impl<T, S> IntoIterator for indexmap::set::IndexSet<T, S>

type Item = T

type IntoIter = IntoIter<T>

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

type Item = T

type IntoIter = IntoIter<T>

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

type Item = T

type IntoIter = IntoIter<T>

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

where A: Allocator + Clone,

type Item = T

type IntoIter = IntoIter<T, A>

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

where A: Allocator + Clone,

type Item = T

type IntoIter = IntoIter<T, A>

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

where A: Allocator,

type Item = T

type IntoIter = IntoIter<T, A>

impl<T, U> IntoIterator for Chain<T, U>

where T: Buf, U: Buf,

type Item = u8

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

impl<T, const CAP: usize> IntoIterator for arrayvec::arrayvec::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]) {
    // ...
}

type Item = T

type IntoIter = IntoIter<T, CAP>

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

type Item = T

type IntoIter = IntoIter<T, N>