Trait tor_hsservice::internal_prelude::iter::FusedIterator

pub trait FusedIterator: Iterator { }

An iterator that always continues to yield None when exhausted.

Calling next on a fused iterator that has returned None once is guaranteed to return None again. This trait should be implemented by all iterators that behave this way because it allows optimizing Iterator::fuse().

Note: In general, you should not use FusedIterator in generic bounds if you need a fused iterator. Instead, you should just call Iterator::fuse() on the iterator. If the iterator is already fused, the additional Fuse wrapper will be a no-op with no performance penalty.

Implementors

impl FusedIterator for DirEventIter

impl FusedIterator for alloc::string::Drain<'_>

impl FusedIterator for core::ascii::EscapeDefault

impl FusedIterator for core::char::EscapeDebug

impl FusedIterator for core::char::EscapeDefault

impl FusedIterator for core::char::EscapeUnicode

impl FusedIterator for ToLowercase

impl FusedIterator for ToUppercase

impl FusedIterator for core::ffi::c_str::Bytes<'_>

impl FusedIterator for core::str::iter::Bytes<'_>

impl FusedIterator for CharIndices<'_>

impl FusedIterator for Chars<'_>

impl FusedIterator for EncodeUtf16<'_>

impl FusedIterator for Lines<'_>

impl FusedIterator for LinesAny<'_>

impl FusedIterator for SplitAsciiWhitespace<'_>

impl FusedIterator for SplitWhitespace<'_>

impl FusedIterator for Utf8Chunks<'_>

impl FusedIterator for Incoming<'_>

impl FusedIterator for IntoIncoming

impl FusedIterator for std::path::Ancestors<'_>

impl FusedIterator for std::path::Components<'_>

impl FusedIterator for std::path::Iter<'_>

impl FusedIterator for U32Digits<'_>

impl FusedIterator for U64Digits<'_>

impl FusedIterator for serde_json::map::IntoIter

impl FusedIterator for Ancestors<'_>

impl FusedIterator for AncillaryDrain<'_>

impl FusedIterator for Components<'_>

impl FusedIterator for IntoIter

impl FusedIterator for Iter<'_>

impl FusedIterator for RelayIdTypeIter

impl FusedIterator for SetMatchesIntoIter

impl FusedIterator for SetMatchesIntoIter

impl FusedIterator for Utf8Sequences

impl<'a> FusedIterator for EscapeAscii<'a>

impl<'a> FusedIterator for core::str::iter::EscapeDebug<'a>

impl<'a> FusedIterator for core::str::iter::EscapeDefault<'a>

impl<'a> FusedIterator for core::str::iter::EscapeUnicode<'a>

impl<'a> FusedIterator for serde_json::map::Iter<'a>

impl<'a> FusedIterator for serde_json::map::IterMut<'a>

impl<'a> FusedIterator for serde_json::map::Keys<'a>

impl<'a> FusedIterator for serde_json::map::Values<'a>

impl<'a> FusedIterator for serde_json::map::ValuesMut<'a>

impl<'a> FusedIterator for BitStringIter<'a>

impl<'a> FusedIterator for CapturesPatternIter<'a>

impl<'a> FusedIterator for GroupInfoPatternNames<'a>

impl<'a> FusedIterator for SetMatchesIter<'a>

impl<'a> FusedIterator for SetMatchesIter<'a>

impl<'a, 'h> FusedIterator for OneIter<'a, 'h>

impl<'a, 'h> FusedIterator for OneIter<'a, 'h>

impl<'a, 'h> FusedIterator for ThreeIter<'a, 'h>

impl<'a, 'h> FusedIterator for ThreeIter<'a, 'h>

impl<'a, 'h> FusedIterator for TwoIter<'a, 'h>

impl<'a, 'h> FusedIterator for TwoIter<'a, 'h>

impl<'a, I, T> FusedIterator for Cloned<I>

where T: 'a + Clone, I: FusedIterator<Item = &'a T>,

impl<'a, I, T> FusedIterator for Copied<I>

where T: 'a + Copy, I: FusedIterator<Item = &'a T>,

impl<'a, K, V> FusedIterator for phf::map::Entries<'a, K, V>

impl<'a, K, V> FusedIterator for phf::map::Keys<'a, K, V>

impl<'a, K, V> FusedIterator for phf::map::Values<'a, K, V>

impl<'a, K, V> FusedIterator for phf::ordered_map::Entries<'a, K, V>

impl<'a, K, V> FusedIterator for phf::ordered_map::Keys<'a, K, V>

impl<'a, K, V> FusedIterator for phf::ordered_map::Values<'a, K, V>

impl<'a, K, V> FusedIterator for Gaps<'a, K, V>

where K: Ord + Clone,

impl<'a, K, V, R> FusedIterator for Overlapping<'a, K, V, R>

where R: Borrow<Range<K>>, K: Ord,

impl<'a, K, V, R> FusedIterator for Overlapping<'a, K, V, R>

where R: Borrow<RangeInclusive<K>>, K: Ord + Clone,

impl<'a, K, V, StepFnsT> FusedIterator for Gaps<'a, K, V, StepFnsT>

where K: Ord + Clone, StepFnsT: StepFns<K>,

impl<'a, P> FusedIterator for MatchIndices<'a, P>

where P: Pattern<'a>,

impl<'a, P> FusedIterator for core::str::iter::Matches<'a, P>

where P: Pattern<'a>,

impl<'a, P> FusedIterator for RMatchIndices<'a, P>

where P: Pattern<'a>, <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,

impl<'a, P> FusedIterator for RMatches<'a, P>

where P: Pattern<'a>, <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,

impl<'a, P> FusedIterator for core::str::iter::RSplit<'a, P>

where P: Pattern<'a>, <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,

impl<'a, P> FusedIterator for core::str::iter::RSplitN<'a, P>

where P: Pattern<'a>, <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,

impl<'a, P> FusedIterator for RSplitTerminator<'a, P>

where P: Pattern<'a>, <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,

impl<'a, P> FusedIterator for core::str::iter::Split<'a, P>

where P: Pattern<'a>,

impl<'a, P> FusedIterator for core::str::iter::SplitInclusive<'a, P>

where P: Pattern<'a>,

impl<'a, P> FusedIterator for core::str::iter::SplitN<'a, P>

where P: Pattern<'a>,

impl<'a, P> FusedIterator for SplitTerminator<'a, P>

where P: Pattern<'a>,

impl<'a, T> FusedIterator for phf::ordered_set::Iter<'a, T>

impl<'a, T> FusedIterator for phf::set::Iter<'a, T>

impl<'a, T> FusedIterator for Append<'a, T>

where T: 'a,

Available on crate feature fused only.

This iterator’s next() will continue to return None when exhausted.

Availability

This trait impl requires the fused feature. However, the guarantee exists even when the trait impl is not present.

impl<'a, T> FusedIterator for ArrayVecDrain<'a, T>

where T: 'a + Default,

impl<'a, T> FusedIterator for Drain<'a, T>

impl<'a, T> FusedIterator for Drain<'a, T>

where T: 'a,

Available on crate feature fused only.

This iterator’s next() will continue to return None when exhausted.

Availability

This trait impl requires the fused feature. However, the guarantee exists even when the trait impl is not present.

impl<'a, T> FusedIterator for Drain<'a, T>

where T: Array,

impl<'a, T> FusedIterator for Gaps<'a, T>

where T: Ord + Clone,

impl<'a, T> FusedIterator for Iter<'a, T>

Available on crate feature fused only.

This iterator’s next() will continue to return None when exhausted.

Availability

This trait impl requires the fused feature. However, the guarantee exists even when the trait impl is not present.

impl<'a, T> FusedIterator for Iter<'a, T>

impl<'a, T> FusedIterator for IterMut<'a, T>

impl<'a, T> FusedIterator for IterMut<'a, T>

where T: 'a,

Available on crate feature fused only.

This iterator’s next() will continue to return None when exhausted.

Availability

This trait impl requires the fused feature. However, the guarantee exists even when the trait impl is not present.

impl<'a, T> FusedIterator for Keys<'a, T>

impl<'a, T> FusedIterator for ValueDrain<'a, T>

impl<'a, T> FusedIterator for ValueIter<'a, T>

impl<'a, T> FusedIterator for ValueIterMut<'a, T>

impl<'a, T> FusedIterator for Values<'a, T>

impl<'a, T> FusedIterator for ValuesMut<'a, T>

impl<'a, T, O> FusedIterator for ChunksExactMutNoAlias<'a, T, O>

where T: 'a + BitStore, O: BitOrder, ChunksExactMut<'a, T, O>: FusedIterator,

impl<'a, T, O> FusedIterator for ChunksMutNoAlias<'a, T, O>

where T: 'a + BitStore, O: BitOrder, ChunksMut<'a, T, O>: FusedIterator,

impl<'a, T, O> FusedIterator for IterMutNoAlias<'a, T, O>

where T: 'a + BitStore, O: BitOrder, IterMut<'a, T, O>: FusedIterator,

impl<'a, T, O> FusedIterator for RChunksExactMutNoAlias<'a, T, O>

where T: 'a + BitStore, O: BitOrder, RChunksExactMut<'a, T, O>: FusedIterator,

impl<'a, T, O> FusedIterator for RChunksMutNoAlias<'a, T, O>

where T: 'a + BitStore, O: BitOrder, RChunksMut<'a, T, O>: FusedIterator,

impl<'a, T, O, P> FusedIterator for RSplit<'a, T, O, P>

where T: 'a + BitStore, O: BitOrder, P: FnMut(usize, &bool) -> bool,

impl<'a, T, O, P> FusedIterator for RSplitMut<'a, T, O, P>

where T: 'a + BitStore, O: BitOrder, P: FnMut(usize, &bool) -> bool,

impl<'a, T, O, P> FusedIterator for RSplitMutNoAlias<'a, T, O, P>

where T: 'a + BitStore, O: BitOrder, P: FnMut(usize, &bool) -> bool, RSplitMut<'a, T, O, P>: FusedIterator,

impl<'a, T, O, P> FusedIterator for RSplitNMutNoAlias<'a, T, O, P>

where T: 'a + BitStore, O: BitOrder, P: FnMut(usize, &bool) -> bool, RSplitNMut<'a, T, O, P>: FusedIterator,

impl<'a, T, O, P> FusedIterator for Split<'a, T, O, P>

where T: 'a + BitStore, O: BitOrder, P: FnMut(usize, &bool) -> bool,

impl<'a, T, O, P> FusedIterator for SplitInclusive<'a, T, O, P>

where T: 'a + BitStore, O: BitOrder, P: FnMut(usize, &bool) -> bool,

impl<'a, T, O, P> FusedIterator for SplitInclusiveMut<'a, T, O, P>

where T: 'a + BitStore, O: BitOrder, P: FnMut(usize, &bool) -> bool,

impl<'a, T, O, P> FusedIterator for SplitInclusiveMutNoAlias<'a, T, O, P>

where T: 'a + BitStore, O: BitOrder, P: FnMut(usize, &bool) -> bool, SplitInclusiveMut<'a, T, O, P>: FusedIterator,

impl<'a, T, O, P> FusedIterator for SplitMut<'a, T, O, P>

where T: 'a + BitStore, O: BitOrder, P: FnMut(usize, &bool) -> bool,

impl<'a, T, O, P> FusedIterator for SplitMutNoAlias<'a, T, O, P>

where T: 'a + BitStore, O: BitOrder, P: FnMut(usize, &bool) -> bool, SplitMut<'a, T, O, P>: FusedIterator,

impl<'a, T, O, P> FusedIterator for SplitNMutNoAlias<'a, T, O, P>

where T: 'a + BitStore, O: BitOrder, P: FnMut(usize, &bool) -> bool, SplitNMut<'a, T, O, P>: FusedIterator,

impl<'a, T, P> FusedIterator for ChunkBy<'a, T, P>

where T: 'a, P: FnMut(&T, &T) -> bool,

impl<'a, T, P> FusedIterator for ChunkByMut<'a, T, P>

where T: 'a, P: FnMut(&T, &T) -> bool,

impl<'a, T, P> FusedIterator for core::slice::iter::RSplitN<'a, T, P>

where P: FnMut(&T) -> bool,

impl<'a, T, P> FusedIterator for core::slice::iter::RSplitNMut<'a, T, P>

where P: FnMut(&T) -> bool,

impl<'a, T, P> FusedIterator for core::slice::iter::SplitN<'a, T, P>

where P: FnMut(&T) -> bool,

impl<'a, T, P> FusedIterator for core::slice::iter::SplitNMut<'a, T, P>

where P: FnMut(&T) -> bool,

impl<'a, T, R> FusedIterator for Overlapping<'a, T, R>

where R: Borrow<Range<T>>, T: Ord + Clone,

impl<'a, T, R> FusedIterator for Overlapping<'a, T, R>

where R: Borrow<RangeInclusive<T>>, T: Ord + Clone,

impl<'a, T, StepFnsT> FusedIterator for Gaps<'a, T, StepFnsT>

where T: Ord + Clone, StepFnsT: StepFns<T>,

impl<'c, 'h> FusedIterator for SubCaptureMatches<'c, 'h>

impl<'c, 'h> FusedIterator for SubCaptureMatches<'c, 'h>

impl<'de, R, T> FusedIterator for StreamDeserializer<'de, R, T>

where R: Read<'de> + Fused, T: Deserialize<'de>,

impl<'h> FusedIterator for Memchr2<'h>

impl<'h> FusedIterator for Memchr3<'h>

impl<'h> FusedIterator for Memchr<'h>

impl<'p, 's, T> FusedIterator for SliceVecDrain<'p, 's, T>

where T: Default,

impl<'p, A, I> FusedIterator for ArrayVecSplice<'p, A, I>

where A: Array, I: Iterator<Item = <A as Array>::Item>,

impl<'p, A, I> FusedIterator for TinyVecSplice<'p, A, I>

where A: Array, I: Iterator<Item = <A as Array>::Item>,

impl<'r> FusedIterator for CaptureNames<'r>

impl<'r> FusedIterator for CaptureNames<'r>

impl<'r, 'h> FusedIterator for CaptureMatches<'r, 'h>

impl<'r, 'h> FusedIterator for CaptureMatches<'r, 'h>

impl<'r, 'h> FusedIterator for CapturesMatches<'r, 'h>

impl<'r, 'h> FusedIterator for FindMatches<'r, 'h>

impl<'r, 'h> FusedIterator for Matches<'r, 'h>

impl<'r, 'h> FusedIterator for Matches<'r, 'h>

impl<'r, 'h> FusedIterator for Split<'r, 'h>

impl<'r, 'h> FusedIterator for Split<'r, 'h>

impl<'r, 'h> FusedIterator for Split<'r, 'h>

impl<'r, 'h> FusedIterator for SplitN<'r, 'h>

impl<'r, 'h> FusedIterator for SplitN<'r, 'h>

impl<'r, 'h> FusedIterator for SplitN<'r, 'h>

impl<A> FusedIterator for core::ops::range::Range<A>

where A: Step,

impl<A> FusedIterator for RangeFrom<A>

where A: Step,

impl<A> FusedIterator for RangeInclusive<A>

where A: Step,

impl<A> FusedIterator for core::option::IntoIter<A>

impl<A> FusedIterator for core::option::Iter<'_, A>

impl<A> FusedIterator for core::option::IterMut<'_, A>

impl<A> FusedIterator for Repeat<A>

where A: Clone,

impl<A> FusedIterator for tor_hsservice::internal_prelude::iter::RepeatN<A>

where A: Clone,

impl<A> FusedIterator for ArrayVecIterator<A>

where A: Array,

impl<A> FusedIterator for IntoIter<A>

where A: Array,

impl<A> FusedIterator for RepeatN<A>

where A: Clone,

impl<A> FusedIterator for TinyVecIterator<A>

where A: Array,

impl<A, B> FusedIterator for Chain<A, B>

where A: FusedIterator, B: FusedIterator<Item = <A as Iterator>::Item>,

impl<A, B> FusedIterator for Zip<A, B>

where A: FusedIterator, B: FusedIterator,

impl<A, F> FusedIterator for OnceWith<F>

where F: FnOnce() -> A,

impl<A, F> FusedIterator for RepeatWith<F>

where F: FnMut() -> A,

impl<A, I> FusedIterator for RcIter<I>

where I: FusedIterator<Item = A>,

impl<A, O> FusedIterator for IntoIter<A, O>

where A: BitViewSized, O: BitOrder,

impl<B, I, F> FusedIterator for FilterMap<I, F>

where I: FusedIterator, F: FnMut(<I as Iterator>::Item) -> Option<B>,

impl<B, I, F> FusedIterator for Map<I, F>

where I: FusedIterator, F: FnMut(<I as Iterator>::Item) -> B,

impl<D, R, T> FusedIterator for DistIter<D, R, T>

where D: Distribution<T>, R: Rng,

impl<I> FusedIterator for &mut I

where I: FusedIterator + ?Sized,

impl<I> FusedIterator for DecodeUtf16<I>

where I: Iterator<Item = u16> + FusedIterator,

impl<I> FusedIterator for Cycle<I>

where I: Clone + Iterator,

impl<I> FusedIterator for Enumerate<I>

where I: FusedIterator,

impl<I> FusedIterator for Fuse<I>

where I: Iterator,

impl<I> FusedIterator for Intersperse<I>

where I: FusedIterator, <I as Iterator>::Item: Clone,

impl<I> FusedIterator for Peekable<I>

where I: FusedIterator,

impl<I> FusedIterator for Rev<I>

where I: FusedIterator + DoubleEndedIterator,

impl<I> FusedIterator for Skip<I>

where I: FusedIterator,

impl<I> FusedIterator for Take<I>

where I: FusedIterator,

impl<I> FusedIterator for Bidi<I>

where I: DoubleEndedIterator + FusedIterator,

impl<I> FusedIterator for Combinations<I>

where I: Iterator, <I as Iterator>::Item: Clone,

impl<I> FusedIterator for CombinationsWithReplacement<I>

where I: Iterator, <I as Iterator>::Item: Clone,

impl<I> FusedIterator for Permutations<I>

where I: Iterator, <I as Iterator>::Item: Clone,

impl<I> FusedIterator for Powerset<I>

where I: Iterator, <I as Iterator>::Item: Clone,

impl<I> FusedIterator for Unique<I>

where I: FusedIterator, <I as Iterator>::Item: Eq + Hash + Clone,

impl<I> FusedIterator for WithPosition<I>

where I: Iterator,

impl<I, A> FusedIterator for alloc::boxed::Box<I, A>

where I: FusedIterator + ?Sized, A: Allocator,

impl<I, A> FusedIterator for Box<I, A>

where I: FusedIterator + ?Sized, A: Allocator,

impl<I, ElemF> FusedIterator for IntersperseWith<I, ElemF>

where I: Iterator, ElemF: IntersperseElement<<I as Iterator>::Item>,

impl<I, F> FusedIterator for Inspect<I, F>

where I: FusedIterator, F: FnMut(&<I as Iterator>::Item),

impl<I, F> FusedIterator for KMergeBy<I, F>

where I: Iterator, F: KMergePredicate<<I as Iterator>::Item>,

impl<I, F> FusedIterator for PadUsing<I, F>

where I: FusedIterator, F: FnMut(usize) -> <I as Iterator>::Item,

impl<I, F> FusedIterator for Positions<I, F>

where I: FusedIterator, F: FnMut(<I as Iterator>::Item) -> bool,

impl<I, F> FusedIterator for TakeWhileInclusive<I, F>

where I: Iterator, F: FnMut(&<I as Iterator>::Item) -> bool,

impl<I, F> FusedIterator for Update<I, F>

where I: FusedIterator, F: FnMut(&mut <I as Iterator>::Item),

impl<I, F, R, const N: usize> FusedIterator for MapWindows<I, F, N>

where I: Iterator, F: FnMut(&[<I as Iterator>::Item; N]) -> R,

impl<I, F, T, E> FusedIterator for FilterOk<I, F>

where I: FusedIterator<Item = Result<T, E>>, F: FnMut(&T) -> bool,

impl<I, F, T, U, E> FusedIterator for FilterMapOk<I, F>

where I: FusedIterator<Item = Result<T, E>>, F: FnMut(T) -> Option<U>,

impl<I, G> FusedIterator for tor_hsservice::internal_prelude::iter::IntersperseWith<I, G>

where I: FusedIterator, G: FnMut() -> <I as Iterator>::Item,

impl<I, J> FusedIterator for Interleave<I, J>

where I: Iterator, J: Iterator<Item = <I as Iterator>::Item>,

impl<I, J> FusedIterator for InterleaveShortest<I, J>

where I: FusedIterator, J: FusedIterator<Item = <I as Iterator>::Item>,

impl<I, J> FusedIterator for Product<I, J>

where I: FusedIterator, J: Clone + FusedIterator, <I as Iterator>::Item: Clone,

impl<I, J, F> FusedIterator for MergeBy<I, J, F>

where I: Iterator, J: Iterator, F: OrderingOrBool<<I as Iterator>::Item, <J as Iterator>::Item>,

impl<I, K, V, S> FusedIterator for Splice<'_, I, K, V, S>

where I: Iterator<Item = (K, V)>, K: Hash + Eq, S: BuildHasher,

impl<I, P> FusedIterator for Filter<I, P>

where I: FusedIterator, P: FnMut(&<I as Iterator>::Item) -> bool,

impl<I, P> FusedIterator for SkipWhile<I, P>

where I: FusedIterator, P: FnMut(&<I as Iterator>::Item) -> bool,

impl<I, P> FusedIterator for TakeWhile<I, P>

where I: FusedIterator, P: FnMut(&<I as Iterator>::Item) -> bool,

impl<I, T> FusedIterator for CircularTupleWindows<I, T>

where I: Iterator<Item = <T as TupleCollect>::Item> + Clone, T: TupleCollect + Clone, <T as TupleCollect>::Item: Clone,

impl<I, T> FusedIterator for TupleCombinations<I, T>

where I: FusedIterator, T: HasCombination<I>,

impl<I, T> FusedIterator for TupleWindows<I, T>

where I: FusedIterator<Item = <T as TupleCollect>::Item>, T: HomogeneousTuple + Clone, <T as TupleCollect>::Item: Clone,

impl<I, T, E> FusedIterator for FlattenOk<I, T, E>

where I: FusedIterator<Item = Result<T, E>>, T: IntoIterator,

Only the iterator being flattened needs to implement FusedIterator.

impl<I, T, S> FusedIterator for Splice<'_, I, T, S>

where I: Iterator<Item = T>, T: Hash + Eq, S: BuildHasher,

impl<I, U> FusedIterator for Flatten<I>

where I: FusedIterator, <I as Iterator>::Item: IntoIterator<IntoIter = U, Item = <U as Iterator>::Item>, U: Iterator,

impl<I, U, F> FusedIterator for FlatMap<I, U, F>

where I: FusedIterator, U: IntoIterator, F: FnMut(<I as Iterator>::Item) -> U,

impl<I, V, F> FusedIterator for UniqueBy<I, V, F>

where I: FusedIterator, V: Eq + Hash, F: FnMut(&<I as Iterator>::Item) -> V,

impl<I, const N: usize> FusedIterator for tor_hsservice::internal_prelude::iter::ArrayChunks<I, N>

where I: FusedIterator,

impl<K> FusedIterator for std::collections::hash::set::Drain<'_, K>

impl<K> FusedIterator for std::collections::hash::set::IntoIter<K>

impl<K> FusedIterator for std::collections::hash::set::Iter<'_, K>

impl<K> FusedIterator for Iter<'_, K>

impl<K, A> FusedIterator for Drain<'_, K, A>

where A: Allocator,

impl<K, A> FusedIterator for IntoIter<K, A>

where A: Allocator,

impl<K, F> FusedIterator for std::collections::hash::set::ExtractIf<'_, K, F>

where F: FnMut(&K) -> bool,

impl<K, F, A> FusedIterator for ExtractIf<'_, K, F, A>

where A: Allocator, F: FnMut(&K) -> bool,

impl<K, V> FusedIterator for alloc::collections::btree::map::Iter<'_, K, V>

impl<K, V> FusedIterator for alloc::collections::btree::map::IterMut<'_, K, V>

impl<K, V> FusedIterator for alloc::collections::btree::map::Keys<'_, K, V>

impl<K, V> FusedIterator for alloc::collections::btree::map::Range<'_, K, V>

impl<K, V> FusedIterator for RangeMut<'_, K, V>

impl<K, V> FusedIterator for alloc::collections::btree::map::Values<'_, K, V>

impl<K, V> FusedIterator for alloc::collections::btree::map::ValuesMut<'_, K, V>

impl<K, V> FusedIterator for std::collections::hash::map::Drain<'_, K, V>

impl<K, V> FusedIterator for std::collections::hash::map::IntoIter<K, V>

impl<K, V> FusedIterator for std::collections::hash::map::IntoKeys<K, V>

impl<K, V> FusedIterator for std::collections::hash::map::IntoValues<K, V>

impl<K, V> FusedIterator for std::collections::hash::map::Iter<'_, K, V>

impl<K, V> FusedIterator for std::collections::hash::map::IterMut<'_, K, V>

impl<K, V> FusedIterator for std::collections::hash::map::Keys<'_, K, V>

impl<K, V> FusedIterator for std::collections::hash::map::Values<'_, K, V>

impl<K, V> FusedIterator for std::collections::hash::map::ValuesMut<'_, K, V>

impl<K, V> FusedIterator for Drain<'_, K, V>

impl<K, V> FusedIterator for IntoIter<K, V>

impl<K, V> FusedIterator for IntoKeys<K, V>

impl<K, V> FusedIterator for IntoValues<K, V>

impl<K, V> FusedIterator for Iter<'_, K, V>

impl<K, V> FusedIterator for Iter<'_, K, V>

impl<K, V> FusedIterator for IterMut<'_, K, V>

impl<K, V> FusedIterator for IterMut<'_, K, V>

impl<K, V> FusedIterator for Keys<'_, K, V>

impl<K, V> FusedIterator for Keys<'_, K, V>

impl<K, V> FusedIterator for Values<'_, K, V>

impl<K, V> FusedIterator for Values<'_, K, V>

impl<K, V> FusedIterator for ValuesMut<'_, K, V>

impl<K, V> FusedIterator for ValuesMut<'_, K, V>

impl<K, V, A> FusedIterator for alloc::collections::btree::map::IntoIter<K, V, A>

where A: Allocator + Clone,

impl<K, V, A> FusedIterator for alloc::collections::btree::map::IntoKeys<K, V, A>

where A: Allocator + Clone,

impl<K, V, A> FusedIterator for alloc::collections::btree::map::IntoValues<K, V, A>

where A: Allocator + Clone,

impl<K, V, A> FusedIterator for Drain<'_, K, V, A>

where A: Allocator,

impl<K, V, A> FusedIterator for IntoIter<K, V, A>

where A: Allocator,

impl<K, V, A> FusedIterator for IntoKeys<K, V, A>

where A: Allocator,

impl<K, V, A> FusedIterator for IntoValues<K, V, A>

where A: Allocator,

impl<K, V, F> FusedIterator for alloc::collections::btree::map::ExtractIf<'_, K, V, F>

where F: FnMut(&K, &mut V) -> bool,

impl<K, V, F> FusedIterator for std::collections::hash::map::ExtractIf<'_, K, V, F>

where F: FnMut(&K, &mut V) -> bool,

impl<K, V, F> FusedIterator for ExtractIf<'_, K, V, F>

where F: FnMut(&K, &mut V) -> bool,

impl<L, R> FusedIterator for Either<L, R>

where L: FusedIterator, R: FusedIterator<Item = <L as Iterator>::Item>,

impl<L, R> FusedIterator for IterEither<L, R>

where L: FusedIterator, R: FusedIterator,

impl<M, T, O> FusedIterator for BitPtrRange<M, T, O>

where M: Mutability, T: BitStore, O: BitOrder,

impl<P> FusedIterator for FilterEntry<IntoIter, P>

where P: FnMut(&DirEntry) -> bool,

impl<T> FusedIterator for alloc::collections::binary_heap::Iter<'_, T>

impl<T> FusedIterator for alloc::collections::btree::set::Iter<'_, T>

impl<T> FusedIterator for alloc::collections::btree::set::Range<'_, T>

impl<T> FusedIterator for alloc::collections::btree::set::SymmetricDifference<'_, T>

where T: Ord,

impl<T> FusedIterator for alloc::collections::btree::set::Union<'_, T>

where T: Ord,

impl<T> FusedIterator for alloc::collections::linked_list::Iter<'_, T>

impl<T> FusedIterator for alloc::collections::linked_list::IterMut<'_, T>

impl<T> FusedIterator for alloc::collections::vec_deque::iter::Iter<'_, T>

impl<T> FusedIterator for alloc::collections::vec_deque::iter_mut::IterMut<'_, T>

impl<T> FusedIterator for core::result::IntoIter<T>

impl<T> FusedIterator for core::result::Iter<'_, T>

impl<T> FusedIterator for core::result::IterMut<'_, T>

impl<T> FusedIterator for core::slice::iter::Chunks<'_, T>

impl<T> FusedIterator for core::slice::iter::ChunksExact<'_, T>

impl<T> FusedIterator for core::slice::iter::ChunksExactMut<'_, T>

impl<T> FusedIterator for core::slice::iter::ChunksMut<'_, T>

impl<T> FusedIterator for core::slice::iter::Iter<'_, T>

impl<T> FusedIterator for core::slice::iter::IterMut<'_, T>

impl<T> FusedIterator for core::slice::iter::RChunks<'_, T>

impl<T> FusedIterator for core::slice::iter::RChunksExact<'_, T>

impl<T> FusedIterator for core::slice::iter::RChunksExactMut<'_, T>

impl<T> FusedIterator for core::slice::iter::RChunksMut<'_, T>

impl<T> FusedIterator for core::slice::iter::Windows<'_, T>

impl<T> FusedIterator for Empty<T>

impl<T> FusedIterator for Once<T>

impl<T> FusedIterator for AncillaryIter<'_, T>

impl<T> FusedIterator for Drain<'_, T>

impl<T> FusedIterator for Drain<'_, T>

impl<T> FusedIterator for IntoIter<T>

impl<T> FusedIterator for IntoIter<T>

impl<T> FusedIterator for IntoIter<T>

Available on crate feature fused only.

This iterator’s next() will continue to return None when exhausted.

Availability

This trait impl requires the fused feature. However, the guarantee exists even when the trait impl is not present.

impl<T> FusedIterator for IntoIter<T>

impl<T> FusedIterator for Iter<'_, T>

impl<T> FusedIterator for Iter<'_, T>

impl<T> FusedIterator for Iter<'_, T>

impl<T> FusedIterator for IterMut<'_, T>

impl<T> FusedIterator for IterMut<'_, T>

impl<T> FusedIterator for PermitIterator<'_, T>

impl<T> FusedIterator for RawIter<T>

impl<T, A> FusedIterator for alloc::collections::binary_heap::Drain<'_, T, A>

where A: Allocator,

impl<T, A> FusedIterator for DrainSorted<'_, T, A>

where T: Ord, A: Allocator,

impl<T, A> FusedIterator for alloc::collections::binary_heap::IntoIter<T, A>

where A: Allocator,

impl<T, A> FusedIterator for IntoIterSorted<T, A>

where T: Ord, A: Allocator,

impl<T, A> FusedIterator for alloc::collections::btree::set::Difference<'_, T, A>

where T: Ord, A: Allocator + Clone,

impl<T, A> FusedIterator for alloc::collections::btree::set::Intersection<'_, T, A>

where T: Ord, A: Allocator + Clone,

impl<T, A> FusedIterator for alloc::collections::btree::set::IntoIter<T, A>

where A: Allocator + Clone,

impl<T, A> FusedIterator for alloc::collections::linked_list::IntoIter<T, A>

where A: Allocator,

impl<T, A> FusedIterator for alloc::collections::vec_deque::drain::Drain<'_, T, A>

where A: Allocator,

impl<T, A> FusedIterator for alloc::collections::vec_deque::into_iter::IntoIter<T, A>

where A: Allocator,

impl<T, A> FusedIterator for alloc::vec::drain::Drain<'_, T, A>

where A: Allocator,

impl<T, A> FusedIterator for alloc::vec::into_iter::IntoIter<T, A>

where A: Allocator,

impl<T, A> FusedIterator for Drain<'_, T, A>

where A: Allocator,

impl<T, A> FusedIterator for Drain<'_, T, A>

where A: Allocator,

impl<T, A> FusedIterator for IntoIter<T, A>

where A: Allocator,

impl<T, A> FusedIterator for IntoIter<T, A>

where A: Allocator,

impl<T, A> FusedIterator for RawDrain<'_, T, A>

where A: Allocator,

impl<T, A> FusedIterator for RawIntoIter<T, A>

where A: Allocator,

impl<T, F> FusedIterator for Successors<T, F>

where F: FnMut(&T) -> Option<T>,

impl<T, F, A> FusedIterator for alloc::collections::btree::set::ExtractIf<'_, T, F, A>

where A: Allocator + Clone, F: FnMut(&T) -> bool,

impl<T, F, A> FusedIterator for ExtractIf<'_, T, F, A>

where A: Allocator, F: FnMut(&mut T) -> bool,

impl<T, N> FusedIterator for GenericArrayIter<T, N>

where N: ArrayLength<T>,

impl<T, O> FusedIterator for BitValIter<'_, T, O>

where T: BitStore, O: BitOrder,

impl<T, O> FusedIterator for Chunks<'_, T, O>

where T: BitStore, O: BitOrder,

impl<T, O> FusedIterator for ChunksExact<'_, T, O>

where T: BitStore, O: BitOrder,

impl<T, O> FusedIterator for ChunksExactMut<'_, T, O>

where T: BitStore, O: BitOrder,

impl<T, O> FusedIterator for ChunksMut<'_, T, O>

where T: BitStore, O: BitOrder,

impl<T, O> FusedIterator for Domain<'_, Const, T, O>

where T: BitStore, O: BitOrder,

impl<T, O> FusedIterator for Drain<'_, T, O>

where T: BitStore, O: BitOrder,

Original

impl<T, O> FusedIterator for IntoIter<T, O>

where T: BitStore, O: BitOrder,

impl<T, O> FusedIterator for Iter<'_, T, O>

where T: BitStore, O: BitOrder,

Original and Original

impl<T, O> FusedIterator for IterMut<'_, T, O>

where T: BitStore, O: BitOrder,

Original and Original

impl<T, O> FusedIterator for IterOnes<'_, T, O>

where T: BitStore, O: BitOrder,

impl<T, O> FusedIterator for IterZeros<'_, T, O>

where T: BitStore, O: BitOrder,

impl<T, O> FusedIterator for RChunks<'_, T, O>

where T: BitStore, O: BitOrder,

impl<T, O> FusedIterator for RChunksExact<'_, T, O>

where T: BitStore, O: BitOrder,

impl<T, O> FusedIterator for RChunksExactMut<'_, T, O>

where T: BitStore, O: BitOrder,

impl<T, O> FusedIterator for RChunksMut<'_, T, O>

where T: BitStore, O: BitOrder,

impl<T, O> FusedIterator for Windows<'_, T, O>

where T: BitStore, O: BitOrder,

impl<T, O, I> FusedIterator for Splice<'_, T, O, I>

where T: BitStore, O: BitOrder, I: Iterator<Item = bool>,

impl<T, O, P> FusedIterator for RSplitN<'_, T, O, P>

where T: BitStore, O: BitOrder, P: FnMut(usize, &bool) -> bool,

impl<T, O, P> FusedIterator for RSplitNMut<'_, T, O, P>

where T: BitStore, O: BitOrder, P: FnMut(usize, &bool) -> bool,

impl<T, O, P> FusedIterator for SplitN<'_, T, O, P>

where T: BitStore, O: BitOrder, P: FnMut(usize, &bool) -> bool,

impl<T, O, P> FusedIterator for SplitNMut<'_, T, O, P>

where T: BitStore, O: BitOrder, P: FnMut(usize, &bool) -> bool,

impl<T, P> FusedIterator for core::slice::iter::RSplit<'_, T, P>

where P: FnMut(&T) -> bool,

impl<T, P> FusedIterator for core::slice::iter::RSplitMut<'_, T, P>

where P: FnMut(&T) -> bool,

impl<T, P> FusedIterator for core::slice::iter::Split<'_, T, P>

where P: FnMut(&T) -> bool,

impl<T, P> FusedIterator for core::slice::iter::SplitInclusive<'_, T, P>

where P: FnMut(&T) -> bool,

impl<T, P> FusedIterator for core::slice::iter::SplitInclusiveMut<'_, T, P>

where P: FnMut(&T) -> bool,

impl<T, P> FusedIterator for core::slice::iter::SplitMut<'_, T, P>

where P: FnMut(&T) -> bool,

impl<T, S1, S2> FusedIterator for SymmetricDifference<'_, T, S1, S2>

where T: Eq + Hash, S1: BuildHasher, S2: BuildHasher,

impl<T, S> FusedIterator for std::collections::hash::set::Difference<'_, T, S>

where T: Eq + Hash, S: BuildHasher,

impl<T, S> FusedIterator for std::collections::hash::set::Intersection<'_, T, S>

where T: Eq + Hash, S: BuildHasher,

impl<T, S> FusedIterator for std::collections::hash::set::SymmetricDifference<'_, T, S>

where T: Eq + Hash, S: BuildHasher,

impl<T, S> FusedIterator for std::collections::hash::set::Union<'_, T, S>

where T: Eq + Hash, S: BuildHasher,

impl<T, S> FusedIterator for Difference<'_, T, S>

where T: Eq + Hash, S: BuildHasher,

impl<T, S> FusedIterator for Intersection<'_, T, S>

where T: Eq + Hash, S: BuildHasher,

impl<T, S> FusedIterator for Union<'_, T, S>

where T: Eq + Hash, S: BuildHasher,

impl<T, S, A> FusedIterator for Difference<'_, T, S, A>

where T: Eq + Hash, S: BuildHasher, A: Allocator,

impl<T, S, A> FusedIterator for Intersection<'_, T, S, A>

where T: Eq + Hash, S: BuildHasher, A: Allocator,

impl<T, S, A> FusedIterator for SymmetricDifference<'_, T, S, A>

where T: Eq + Hash, S: BuildHasher, A: Allocator,

impl<T, S, A> FusedIterator for Union<'_, T, S, A>

where T: Eq + Hash, S: BuildHasher, A: Allocator,

impl<T, U> FusedIterator for ZipLongest<T, U>

where T: Iterator, U: Iterator,

impl<T, const N: usize> FusedIterator for core::array::iter::IntoIter<T, N>

impl<T, const N: usize> FusedIterator for core::slice::iter::ArrayChunks<'_, T, N>

impl<T, const N: usize> FusedIterator for ArrayChunksMut<'_, T, N>