Trait tor_hsservice::internal_prelude::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 CipherCtxFlags

type Item = CipherCtxFlags

type IntoIter = Iter<CipherCtxFlags>

impl IntoIterator for CMSOptions

type Item = CMSOptions

type IntoIter = Iter<CMSOptions>

impl IntoIterator for OcspFlag

type Item = OcspFlag

type IntoIter = Iter<OcspFlag>

impl IntoIterator for Pkcs7Flags

type Item = Pkcs7Flags

type IntoIter = Iter<Pkcs7Flags>

impl IntoIterator for ExtensionContext

type Item = ExtensionContext

type IntoIter = Iter<ExtensionContext>

impl IntoIterator for ShutdownState

type Item = ShutdownState

type IntoIter = Iter<ShutdownState>

impl IntoIterator for SslMode

type Item = SslMode

type IntoIter = Iter<SslMode>

impl IntoIterator for SslOptions

type Item = SslOptions

type IntoIter = Iter<SslOptions>

impl IntoIterator for SslSessionCacheMode

type Item = SslSessionCacheMode

type IntoIter = Iter<SslSessionCacheMode>

impl IntoIterator for SslVerifyMode

type Item = SslVerifyMode

type IntoIter = Iter<SslVerifyMode>

impl IntoIterator for X509CheckFlags

type Item = X509CheckFlags

type IntoIter = Iter<X509CheckFlags>

impl IntoIterator for X509VerifyFlags

type Item = X509VerifyFlags

type IntoIter = Iter<X509VerifyFlags>

impl IntoIterator for ByteBuf

type Item = u8

type IntoIter = <Vec<u8> as IntoIterator>::IntoIter

impl IntoIterator for serde_json::map::Map<String, Value>

type Item = (String, Value)

type IntoIter = IntoIter

impl IntoIterator for Access

type Item = Access

type IntoIter = Iter<Access>

impl IntoIterator for Array

type Item = Value

type IntoIter = Box<dyn Iterator<Item = Value>>

impl IntoIterator for ArrayOfTables

type Item = Table

type IntoIter = Box<dyn Iterator<Item = Table>>

impl IntoIterator for AtFlags

type Item = AtFlags

type IntoIter = Iter<AtFlags>

impl IntoIterator for BeginFlags

type Item = BeginFlags

type IntoIter = Iter<BeginFlags>

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 CreateFlags

type Item = CreateFlags

type IntoIter = Iter<CreateFlags>

impl IntoIterator for DupFlags

type Item = DupFlags

type IntoIter = Iter<DupFlags>

impl IntoIterator for Error

type Item = Error

type IntoIter = IntoIter

impl IntoIterator for EventFlags

type Item = EventFlags

type IntoIter = Iter<EventFlags>

impl IntoIterator for EventfdFlags

type Item = EventfdFlags

type IntoIter = Iter<EventfdFlags>

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 FloatingPointEmulationControl

type Item = FloatingPointEmulationControl

type IntoIter = Iter<FloatingPointEmulationControl>

impl IntoIterator for FloatingPointExceptionMode

type Item = FloatingPointExceptionMode

type IntoIter = Iter<FloatingPointExceptionMode>

impl IntoIterator for IFlags

type Item = IFlags

type IntoIter = Iter<IFlags>

impl IntoIterator for InlineTable

type Item = (InternalString, Value)

type IntoIter = Box<dyn Iterator<Item = (InternalString, Value)>>

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 Map<String, Value>

type Item = (String, Value)

type IntoIter = IntoIter

impl IntoIterator for MembarrierQuery

type Item = MembarrierQuery

type IntoIter = Iter<MembarrierQuery>

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 PidfdFlags

type Item = PidfdFlags

type IntoIter = Iter<PidfdFlags>

impl IntoIterator for PidfdGetfdFlags

type Item = PidfdGetfdFlags

type IntoIter = Iter<PidfdGetfdFlags>

impl IntoIterator for PipeFlags

type Item = PipeFlags

type IntoIter = Iter<PipeFlags>

impl IntoIterator for PollFlags

type Item = PollFlags

type IntoIter = Iter<PollFlags>

impl IntoIterator for ReadWriteFlags

type Item = ReadWriteFlags

type IntoIter = Iter<ReadWriteFlags>

impl IntoIterator for RecvFlags

type Item = RecvFlags

type IntoIter = Iter<RecvFlags>

impl IntoIterator for RelayFlags

type Item = RelayFlags

type IntoIter = Iter<RelayFlags>

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 SendFlags

type Item = SendFlags

type IntoIter = Iter<SendFlags>

impl IntoIterator for SetMatches

type IntoIter = SetMatchesIntoIter

type Item = usize

impl IntoIterator for SetMatches

type IntoIter = SetMatchesIntoIter

type Item = usize

impl IntoIterator for SockaddrXdpFlags

type Item = SockaddrXdpFlags

type IntoIter = Iter<SockaddrXdpFlags>

impl IntoIterator for SocketFlags

type Item = SocketFlags

type IntoIter = Iter<SocketFlags>

impl IntoIterator for SpeculationFeatureControl

type Item = SpeculationFeatureControl

type IntoIter = Iter<SpeculationFeatureControl>

impl IntoIterator for SpeculationFeatureState

type Item = SpeculationFeatureState

type IntoIter = Iter<SpeculationFeatureState>

impl IntoIterator for SpliceFlags

type Item = SpliceFlags

type IntoIter = Iter<SpliceFlags>

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 Table

type Item = (InternalString, Item)

type IntoIter = Box<dyn Iterator<Item = (InternalString, Item)>>

impl IntoIterator for TimerfdFlags

type Item = TimerfdFlags

type IntoIter = Iter<TimerfdFlags>

impl IntoIterator for TimerfdTimerFlags

type Item = TimerfdTimerFlags

type IntoIter = Iter<TimerfdTimerFlags>

impl IntoIterator for UnalignedAccessControl

type Item = UnalignedAccessControl

type IntoIter = Iter<UnalignedAccessControl>

impl IntoIterator for UnmountFlags

type Item = UnmountFlags

type IntoIter = Iter<UnmountFlags>

impl IntoIterator for WaitOptions

type Item = WaitOptions

type IntoIter = Iter<WaitOptions>

impl IntoIterator for WaitidOptions

type Item = WaitidOptions

type IntoIter = Iter<WaitidOptions>

impl IntoIterator for WalkDir

type Item = Result<DirEntry, Error>

type IntoIter = IntoIter

impl IntoIterator for WatchFlags

type Item = WatchFlags

type IntoIter = Iter<WatchFlags>

impl IntoIterator for XattrFlags

type Item = XattrFlags

type IntoIter = Iter<XattrFlags>

impl IntoIterator for XdpDescOptions

type Item = XdpDescOptions

type IntoIter = Iter<XdpDescOptions>

impl IntoIterator for XdpOptionsFlags

type Item = XdpOptionsFlags

type IntoIter = Iter<XdpOptionsFlags>

impl IntoIterator for XdpRingFlags

type Item = XdpRingFlags

type IntoIter = Iter<XdpRingFlags>

impl IntoIterator for XdpUmemRegFlags

type Item = XdpUmemRegFlags

type IntoIter = Iter<XdpUmemRegFlags>

impl<'a> IntoIterator for &'a tor_hsservice::internal_prelude::Path

type Item = &'a OsStr

type IntoIter = Iter<'a>

impl<'a> IntoIterator for &'a tor_hsservice::internal_prelude::PathBuf

type Item = &'a OsStr

type IntoIter = Iter<'a>

impl<'a> IntoIterator for &'a UnixListener

type Item = Result<UnixStream, Error>

type IntoIter = Incoming<'a>

impl<'a> IntoIterator for &'a ByteBuf

type Item = &'a u8

type IntoIter = <&'a [u8] as IntoIterator>::IntoIter

impl<'a> IntoIterator for &'a serde_bytes::bytes::Bytes

type Item = &'a u8

type IntoIter = <&'a [u8] as IntoIterator>::IntoIter

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

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

type IntoIter = Iter<'a>

impl<'a> IntoIterator for &'a AsciiStr

Produces references for compatibility with [u8].

(str doesn’t implement IntoIterator for its references, so there is no compatibility to lose.)

type Item = &'a AsciiChar

type IntoIter = CharsRef<'a>

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

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

type IntoIter = DerIterator<'a, BorrowedRevokedCert<'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 EventVec

Available on crate feature alloc only.

type IntoIter = Iter<'a>

type Item = Event

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 Map<String, Value>

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

type IntoIter = Iter<'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 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 mut ByteBuf

type Item = &'a mut u8

type IntoIter = <&'a mut [u8] as IntoIterator>::IntoIter

impl<'a> IntoIterator for &'a mut serde_bytes::bytes::Bytes

type Item = &'a mut u8

type IntoIter = <&'a mut [u8] as IntoIterator>::IntoIter

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

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

type IntoIter = IterMut<'a>

impl<'a> IntoIterator for &'a mut AsciiStr

type Item = &'a mut AsciiChar

type IntoIter = CharsMut<'a>

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

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

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

Available on non-tarpaulin_include only.

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,

Available on non-tarpaulin_include only.

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, I> IntoIterator for &'a IntoChunks<I>

where I: Iterator, <I as Iterator>::Item: 'a,

type Item = Chunk<'a, I>

type IntoIter = Chunks<'a, I>

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>

impl<'a, K, I, F> IntoIterator for &'a GroupBy<K, I, F>

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

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

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

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

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

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

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

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

type IntoIter = Entries<'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 TiSlice<K, V>

type Item = &'a V

type IntoIter = Iter<'a, V>

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

type Item = &'a V

type IntoIter = Iter<'a, 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> IntoIterator for &'a mut TiSlice<K, V>

type Item = &'a mut V

type IntoIter = IterMut<'a, V>

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

type Item = &'a mut V

type IntoIter = IterMut<'a, 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 tor_hsservice::internal_prelude::HashMap<K, V, S>

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

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

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

where K: WeakElement,

type Item = (<K as WeakElement>::Strong, &'a V)

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

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

where K: WeakElement, V: WeakElement,

type Item = (<K as WeakElement>::Strong, <V as WeakElement>::Strong)

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

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

where K: WeakElement,

type Item = (<K as WeakElement>::Strong, &'a V)

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

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

where V: WeakElement,

type Item = (&'a K, <V as WeakElement>::Strong)

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

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

where K: WeakElement, V: WeakElement,

type Item = (<K as WeakElement>::Strong, <V as WeakElement>::Strong)

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 tor_hsservice::internal_prelude::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 PtrWeakKeyHashMap<K, V, S>

where K: WeakElement,

type Item = (<K as WeakElement>::Strong, &'a mut V)

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

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

where K: WeakElement,

type Item = (<K as WeakElement>::Strong, &'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,

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,

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

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

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 Stack<T>

where T: Stackable,

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

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

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

type Item = &'a T

type IntoIter = Iter<'a, T>

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

type Item = &'a T

type IntoIter = Iter<'a, T>

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

type Item = &'a 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 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 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 Stack<T>

where T: Stackable,

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

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

impl<'a, T> IntoIterator for &'a mut BoundedVecDeque<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 Slab<T>

type Item = (usize, &'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, 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 VecDeque<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 LinkedList<T, A>

where A: Allocator,

type Item = &'a T

type IntoIter = Iter<'a, T>

impl<'a, T, A> IntoIterator for &'a alloc::vec::Vec<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 VecDeque<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 alloc::vec::Vec<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 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,

Available on non-tarpaulin_include only.

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,

Available on non-tarpaulin_include only.

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,

Available on non-tarpaulin_include only.

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,

Available on non-tarpaulin_include only.

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 tor_hsservice::internal_prelude::HashSet<T, S>

type Item = &'a T

type IntoIter = Iter<'a, T>

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

where T: WeakElement, <T as WeakElement>::Strong: Deref,

type Item = <T as WeakElement>::Strong

type IntoIter = Iter<'a, T>

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

where T: WeakKey,

type Item = <T as WeakElement>::Strong

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, 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<'a, const N: usize> IntoIterator for &'a ByteArray<N>

type Item = &'a u8

type IntoIter = <&'a [u8; N] as IntoIterator>::IntoIter

impl<'a, const N: usize> IntoIterator for &'a mut ByteArray<N>

type Item = &'a mut u8

type IntoIter = <&'a mut [u8; N] as IntoIterator>::IntoIter

impl<'inp, 'out, T> IntoIterator for InOutBuf<'inp, 'out, T>

type Item = InOut<'inp, 'out, T>

type IntoIter = InOutBufIter<'inp, 'out, T>

impl<'s> IntoIterator for &'s Array

type Item = &'s Value

type IntoIter = Box<dyn Iterator<Item = &'s Value> + 's>

impl<'s> IntoIterator for &'s ArrayOfTables

type Item = &'s Table

type IntoIter = Box<dyn Iterator<Item = &'s Table> + 's>

impl<'s> IntoIterator for &'s InlineTable

type Item = (&'s str, &'s Value)

type IntoIter = Box<dyn Iterator<Item = (&'s str, &'s Value)> + 's>

impl<'s> IntoIterator for &'s Table

type Item = (&'s str, &'s Item)

type IntoIter = Box<dyn Iterator<Item = (&'s str, &'s Item)> + 's>

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

type Item = &'s mut T

type IntoIter = IterMut<'s, T>

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<E> IntoIterator for RetryError<E>

type Item = E

type IntoIter = IntoIter<E>

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 Box<TiSlice<K, V>>

type Item = V

type IntoIter = IntoIter<V>

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

type Item = (RangeInclusive<K>, V)

type IntoIter = IntoIter<K, V>

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

type Item = (Range<K>, V)

type IntoIter = IntoIter<K, V>

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

type Item = V

type IntoIter = IntoIter<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 tor_hsservice::internal_prelude::HashMap<K, V, S>

type Item = (K, V)

type IntoIter = IntoIter<K, V>

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

where K: WeakElement,

type Item = (<K as WeakElement>::Strong, V)

type IntoIter = IntoIter<ByPtr<K>, V>

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

where K: WeakElement, V: WeakElement,

type Item = (<K as WeakElement>::Strong, <V as WeakElement>::Strong)

type IntoIter = IntoIter<ByPtr<K>, V>

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

where K: WeakElement,

type Item = (<K as WeakElement>::Strong, V)

type IntoIter = IntoIter<K, V>

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

where V: WeakElement,

type Item = (K, <V as WeakElement>::Strong)

type IntoIter = IntoIter<K, V>

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

where K: WeakElement, V: WeakElement,

type Item = (<K as WeakElement>::Strong, <V as WeakElement>::Strong)

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,

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 Stack<T>

where T: Stackable,

type IntoIter = IntoIter<T>

type Item = T

impl<T> IntoIterator for ArrayQueue<T>

type Item = T

type IntoIter = IntoIter<T>

impl<T> IntoIterator for BoundedVecDeque<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 RangeInclusiveSet<T>

type Item = RangeInclusive<T>

type IntoIter = IntoIter<T>

impl<T> IntoIterator for RangeSet<T>

type Item = Range<T>

type IntoIter = IntoIter<T>

impl<T> IntoIterator for SegQueue<T>

type Item = T

type IntoIter = IntoIter<T>

impl<T> IntoIterator for Slab<T>

type Item = (usize, T)

type IntoIter = IntoIter<T>

impl<T, A> IntoIterator for BinaryHeap<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 BTreeSet<T, A>

where A: Allocator + Clone,

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 alloc::vec::Vec<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,

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, 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 tor_hsservice::internal_prelude::HashSet<T, S>

type Item = T

type IntoIter = IntoIter<T>

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

where T: WeakElement,

type Item = <T as WeakElement>::Strong

type IntoIter = IntoIter<T>

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

where T: WeakKey,

type Item = <T as WeakElement>::Strong

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,

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 LEN: usize, const REVERSE_STR: bool> IntoIterator for Array<T, LEN, REVERSE_STR>

type Item = T

type IntoIter = IntoIter<T, LEN>

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

type Item = T

type IntoIter = IntoIter<T, N>

impl<const N: usize> IntoIterator for ByteArray<N>

type Item = u8

type IntoIter = <[u8; N] as IntoIterator>::IntoIter