Trait 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 IpAddrRange

impl FusedIterator for IpSubnets

impl FusedIterator for Walk

impl FusedIterator for Ipv4AddrRange

impl FusedIterator for Ipv6AddrRange

impl FusedIterator for Ipv4Subnets

impl FusedIterator for Ipv6Subnets

impl FusedIterator for Utf8Sequences

impl FusedIterator for CharIter

impl FusedIterator for Utf8CharIndices<'_>

impl FusedIterator for ErrorReportingUtf8Chars<'_>

impl FusedIterator for Utf8Chars<'_>

impl FusedIterator for Utf16CharIndices<'_>

impl FusedIterator for ErrorReportingUtf16Chars<'_>

impl FusedIterator for Utf16Chars<'_>

impl FusedIterator for NaiveDateDaysIterator

impl FusedIterator for NaiveDateWeeksIterator

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

impl FusedIterator for WeekdaysForward

impl FusedIterator for WeekdaysReverse

impl FusedIterator for U32Digits<'_>

impl FusedIterator for U64Digits<'_>

impl FusedIterator for rustmax::regex::bytes::SetMatchesIntoIter

impl FusedIterator for rustmax::regex::SetMatchesIntoIter

impl FusedIterator for rustmax::serde_json::map::IntoIter

impl FusedIterator for rustmax::std::ascii::EscapeDefault

impl FusedIterator for rustmax::std::char::EscapeDebug

impl FusedIterator for rustmax::std::char::EscapeDefault

impl FusedIterator for rustmax::std::char::EscapeUnicode

impl FusedIterator for ToLowercase

impl FusedIterator for ToUppercase

impl FusedIterator for Incoming<'_>

impl FusedIterator for IntoIncoming

impl FusedIterator for Ancestors<'_>

impl FusedIterator for Components<'_>

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

impl FusedIterator for rustmax::std::str::Bytes<'_>

impl FusedIterator for rustmax::std::str::CharIndices<'_>

impl FusedIterator for Chars<'_>

impl FusedIterator for EncodeUtf16<'_>

impl FusedIterator for rustmax::std::str::Lines<'_>

impl FusedIterator for LinesAny<'_>

impl FusedIterator for SplitAsciiWhitespace<'_>

impl FusedIterator for SplitWhitespace<'_>

impl FusedIterator for rustmax::std::str::Utf8Chunks<'_>

impl FusedIterator for rustmax::std::string::Drain<'_>

impl FusedIterator for rustmax::walkdir::IntoIter

impl<'a> FusedIterator for bstr::ext_slice::Bytes<'a>

impl<'a> FusedIterator for bstr::ext_slice::Lines<'a>

impl<'a> FusedIterator for LinesWithTerminator<'a>

impl<'a> FusedIterator for DrainBytes<'a>

impl<'a> FusedIterator for bstr::utf8::CharIndices<'a>

impl<'a> FusedIterator for bstr::utf8::Utf8Chunks<'a>

impl<'a> FusedIterator for AsciiCharsIter<'a>

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

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

impl<'a> FusedIterator for Source<'a>

impl<'a> FusedIterator for rustmax::regex::bytes::SetMatchesIter<'a>

impl<'a> FusedIterator for rustmax::regex::SetMatchesIter<'a>

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

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

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

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

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

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

impl<'a> FusedIterator for rustmax::std::str::EscapeDebug<'a>

impl<'a> FusedIterator for rustmax::std::str::EscapeDefault<'a>

impl<'a> FusedIterator for rustmax::std::str::EscapeUnicode<'a>

impl<'a, 'fd> FusedIterator for Fds<'a, 'fd>

impl<'a, 'h> FusedIterator for memchr::arch::x86_64::avx2::memchr::OneIter<'a, 'h>

impl<'a, 'h> FusedIterator for memchr::arch::x86_64::avx2::memchr::ThreeIter<'a, 'h>

impl<'a, 'h> FusedIterator for memchr::arch::x86_64::avx2::memchr::TwoIter<'a, 'h>

impl<'a, 'h> FusedIterator for memchr::arch::x86_64::sse2::memchr::OneIter<'a, 'h>

impl<'a, 'h> FusedIterator for memchr::arch::x86_64::sse2::memchr::ThreeIter<'a, 'h>

impl<'a, 'h> FusedIterator for memchr::arch::x86_64::sse2::memchr::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, P> FusedIterator for MatchIndices<'a, P>

where P: Pattern,

impl<'a, P> FusedIterator for rustmax::std::str::Matches<'a, P>

where P: Pattern,

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

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

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

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

impl<'a, P> FusedIterator for rustmax::std::str::RSplit<'a, P>

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

impl<'a, P> FusedIterator for rustmax::std::str::RSplitN<'a, P>

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

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

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

impl<'a, P> FusedIterator for rustmax::std::str::Split<'a, P>

where P: Pattern,

impl<'a, P> FusedIterator for rustmax::std::str::SplitInclusive<'a, P>

where P: Pattern,

impl<'a, P> FusedIterator for rustmax::std::str::SplitN<'a, P>

where P: Pattern,

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

where P: Pattern,

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 smallvec::Drain<'a, T>

where T: Array,

impl<'a, T> FusedIterator for rustmax::cxx_build::vector::Iter<'a, T>

where T: VectorElement,

impl<'a, T> FusedIterator for rustmax::cxx_build::vector::IterMut<'a, T>

where T: VectorElement,

impl<'a, T> FusedIterator for rustmax::reqwest::header::Drain<'a, T>

impl<'a, T> FusedIterator for rustmax::reqwest::header::Iter<'a, T>

impl<'a, T> FusedIterator for rustmax::reqwest::header::IterMut<'a, T>

impl<'a, T> FusedIterator for rustmax::reqwest::header::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 rustmax::reqwest::header::Values<'a, T>

impl<'a, T> FusedIterator for rustmax::reqwest::header::ValuesMut<'a, T>

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 rustmax::std::slice::RSplitN<'a, T, P>

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

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

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

impl<'a, T, P> FusedIterator for rustmax::std::slice::SplitN<'a, T, P>

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

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

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

impl<'c, 'h> FusedIterator for rustmax::regex::bytes::SubCaptureMatches<'c, 'h>

impl<'c, 'h> FusedIterator for rustmax::regex::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<'r> FusedIterator for rustmax::regex::bytes::CaptureNames<'r>

impl<'r> FusedIterator for rustmax::regex::CaptureNames<'r>

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

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

impl<'r, 'h> FusedIterator for regex_automata::meta::regex::Split<'r, 'h>

impl<'r, 'h> FusedIterator for regex_automata::meta::regex::SplitN<'r, 'h>

impl<'r, 'h> FusedIterator for rustmax::regex::bytes::CaptureMatches<'r, 'h>

impl<'r, 'h> FusedIterator for rustmax::regex::bytes::Matches<'r, 'h>

impl<'r, 'h> FusedIterator for rustmax::regex::bytes::Split<'r, 'h>

impl<'r, 'h> FusedIterator for rustmax::regex::bytes::SplitN<'r, 'h>

impl<'r, 'h> FusedIterator for rustmax::regex::CaptureMatches<'r, 'h>

impl<'r, 'h> FusedIterator for rustmax::regex::Matches<'r, 'h>

impl<'r, 'h> FusedIterator for rustmax::regex::Split<'r, 'h>

impl<'r, 'h> FusedIterator for rustmax::regex::SplitN<'r, 'h>

impl<'t> FusedIterator for TimeZoneFollowingTransitions<'t>

impl<'t> FusedIterator for TimeZonePrecedingTransitions<'t>

impl<A> FusedIterator for itertools::repeatn::RepeatN<A>

where A: Clone,

impl<A> FusedIterator for smallvec::IntoIter<A>

where A: Array,

impl<A> FusedIterator for IterRange<A>

where A: Step,

impl<A> FusedIterator for IterRangeFrom<A>

where A: Step,

impl<A> FusedIterator for IterRangeInclusive<A>

where A: Step,

impl<A> FusedIterator for rustmax::itertools::RepeatN<A>

where A: Clone,

impl<A> FusedIterator for Repeat<A>

where A: Clone,

impl<A> FusedIterator for rustmax::std::iter::RepeatN<A>

where A: Clone,

impl<A> FusedIterator for rustmax::std::ops::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 rustmax::std::option::IntoIter<A>

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

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

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<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<D, R, T> FusedIterator for rustmax::rand::distr::Iter<D, R, T>

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

impl<I> FusedIterator for &mut I

where I: FusedIterator + ?Sized,

impl<I> FusedIterator for itertools::with_position::WithPosition<I>

where I: Iterator,

impl<I> FusedIterator for CombinationsWithReplacement<I>

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

impl<I> FusedIterator for MultiProduct<I>

where I: Iterator + Clone, <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 rustmax::itertools::WithPosition<I>

where I: Iterator,

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, A> FusedIterator for Box<I, A>

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

impl<I, ElemF> FusedIterator for itertools::intersperse::IntersperseWith<I, ElemF>

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

impl<I, ElemF> FusedIterator for rustmax::itertools::IntersperseWith<I, ElemF>

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

impl<I, F> FusedIterator for itertools::adaptors::Positions<I, F>

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

impl<I, F> FusedIterator for itertools::adaptors::Update<I, F>

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

impl<I, F> FusedIterator for itertools::pad_tail::PadUsing<I, F>

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

impl<I, F> FusedIterator for itertools::take_while_inclusive::TakeWhileInclusive<I, F>

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

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

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

impl<I, F> FusedIterator for rustmax::itertools::PadUsing<I, F>

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

impl<I, F> FusedIterator for rustmax::itertools::Positions<I, F>

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

impl<I, F> FusedIterator for rustmax::itertools::TakeWhileInclusive<I, F>

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

impl<I, F> FusedIterator for rustmax::itertools::Update<I, F>

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

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

where I: FusedIterator, F: FnMut(&<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 itertools::adaptors::FilterOk<I, F>

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

impl<I, F, T, E> FusedIterator for rustmax::itertools::FilterOk<I, F>

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

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

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

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

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

impl<I, G> FusedIterator for rustmax::std::iter::IntersperseWith<I, G>

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

impl<I, J> FusedIterator for itertools::adaptors::Interleave<I, J>

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

impl<I, J> FusedIterator for itertools::adaptors::InterleaveShortest<I, J>

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

impl<I, J> FusedIterator for itertools::adaptors::Product<I, J>

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

impl<I, J> FusedIterator for rustmax::itertools::Interleave<I, J>

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

impl<I, J> FusedIterator for rustmax::itertools::InterleaveShortest<I, J>

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

impl<I, J> FusedIterator for rustmax::itertools::Product<I, J>

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

impl<I, J, F> FusedIterator for itertools::merge_join::MergeBy<I, J, F>

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

impl<I, J, F> FusedIterator for rustmax::itertools::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 indexmap::map::iter::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 itertools::adaptors::TupleCombinations<I, T>

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

impl<I, T> FusedIterator for itertools::tuple_impl::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 itertools::tuple_impl::TupleWindows<I, T>

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

impl<I, T> FusedIterator for rustmax::itertools::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 rustmax::itertools::TupleCombinations<I, T>

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

impl<I, T> FusedIterator for rustmax::itertools::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 itertools::flatten_ok::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, E> FusedIterator for rustmax::itertools::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 indexmap::set::iter::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 rustmax::std::iter::ArrayChunks<I, N>

where I: FusedIterator,

impl<K> FusedIterator for hashbrown::set::Iter<'_, K>

impl<K> FusedIterator for rustmax::std::collections::hash_set::Drain<'_, K>

impl<K> FusedIterator for rustmax::std::collections::hash_set::IntoIter<K>

impl<K> FusedIterator for rustmax::std::collections::hash_set::Iter<'_, K>

impl<K, A> FusedIterator for hashbrown::set::Drain<'_, K, A>

where A: Allocator,

impl<K, A> FusedIterator for hashbrown::set::IntoIter<K, A>

where A: Allocator,

impl<K, F> FusedIterator for rustmax::std::collections::hash_set::ExtractIf<'_, K, F>

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

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

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

impl<K, V> FusedIterator for hashbrown::map::Iter<'_, K, V>

impl<K, V> FusedIterator for hashbrown::map::IterMut<'_, K, V>

impl<K, V> FusedIterator for hashbrown::map::Keys<'_, K, V>

impl<K, V> FusedIterator for hashbrown::map::Values<'_, K, V>

impl<K, V> FusedIterator for hashbrown::map::ValuesMut<'_, K, V>

impl<K, V> FusedIterator for indexmap::map::iter::Drain<'_, K, V>

impl<K, V> FusedIterator for indexmap::map::iter::IntoIter<K, V>

impl<K, V> FusedIterator for indexmap::map::iter::IntoKeys<K, V>

impl<K, V> FusedIterator for indexmap::map::iter::IntoValues<K, V>

impl<K, V> FusedIterator for indexmap::map::iter::Iter<'_, K, V>

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

impl<K, V> FusedIterator for indexmap::map::iter::IterMut<'_, K, V>

impl<K, V> FusedIterator for indexmap::map::iter::Keys<'_, K, V>

impl<K, V> FusedIterator for indexmap::map::iter::Values<'_, K, V>

impl<K, V> FusedIterator for indexmap::map::iter::ValuesMut<'_, K, V>

impl<K, V> FusedIterator for rustmax::std::collections::btree_map::Iter<'_, K, V>

impl<K, V> FusedIterator for rustmax::std::collections::btree_map::IterMut<'_, K, V>

impl<K, V> FusedIterator for rustmax::std::collections::btree_map::Keys<'_, K, V>

impl<K, V> FusedIterator for rustmax::std::collections::btree_map::Range<'_, K, V>

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

impl<K, V> FusedIterator for rustmax::std::collections::btree_map::Values<'_, K, V>

impl<K, V> FusedIterator for rustmax::std::collections::btree_map::ValuesMut<'_, K, V>

impl<K, V> FusedIterator for rustmax::std::collections::hash_map::Drain<'_, K, V>

impl<K, V> FusedIterator for rustmax::std::collections::hash_map::IntoIter<K, V>

impl<K, V> FusedIterator for rustmax::std::collections::hash_map::IntoKeys<K, V>

impl<K, V> FusedIterator for rustmax::std::collections::hash_map::IntoValues<K, V>

impl<K, V> FusedIterator for rustmax::std::collections::hash_map::Iter<'_, K, V>

impl<K, V> FusedIterator for rustmax::std::collections::hash_map::IterMut<'_, K, V>

impl<K, V> FusedIterator for rustmax::std::collections::hash_map::Keys<'_, K, V>

impl<K, V> FusedIterator for rustmax::std::collections::hash_map::Values<'_, K, V>

impl<K, V> FusedIterator for rustmax::std::collections::hash_map::ValuesMut<'_, K, V>

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

where A: Allocator,

impl<K, V, A> FusedIterator for hashbrown::map::IntoIter<K, V, A>

where A: Allocator,

impl<K, V, A> FusedIterator for hashbrown::map::IntoKeys<K, V, A>

where A: Allocator,

impl<K, V, A> FusedIterator for hashbrown::map::IntoValues<K, V, A>

where A: Allocator,

impl<K, V, A> FusedIterator for rustmax::std::collections::btree_map::IntoIter<K, V, A>

where A: Allocator + Clone,

impl<K, V, A> FusedIterator for rustmax::std::collections::btree_map::IntoKeys<K, V, A>

where A: Allocator + Clone,

impl<K, V, A> FusedIterator for rustmax::std::collections::btree_map::IntoValues<K, V, A>

where A: Allocator + Clone,

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

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

impl<K, V, F> FusedIterator for rustmax::std::collections::btree_map::ExtractIf<'_, K, V, F>

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

impl<K, V, F> FusedIterator for rustmax::std::collections::hash_map::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<P> FusedIterator for FilterEntry<IntoIter, P>

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

impl<T> FusedIterator for hashbrown::table::Iter<'_, T>

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

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

impl<T> FusedIterator for hashbrown::table::IterMut<'_, T>

impl<T> FusedIterator for indexmap::set::iter::Drain<'_, T>

impl<T> FusedIterator for indexmap::set::iter::IntoIter<T>

impl<T> FusedIterator for indexmap::set::iter::Iter<'_, T>

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

impl<T> FusedIterator for slab::IntoIter<T>

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

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

impl<T> FusedIterator for rustmax::crossbeam::channel::IntoIter<T>

impl<T> FusedIterator for rustmax::crossbeam::channel::Iter<'_, T>

impl<T> FusedIterator for rustmax::reqwest::header::IntoIter<T>

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

impl<T> FusedIterator for rustmax::std::collections::btree_set::Iter<'_, T>

impl<T> FusedIterator for rustmax::std::collections::btree_set::Range<'_, T>

impl<T> FusedIterator for rustmax::std::collections::btree_set::SymmetricDifference<'_, T>

where T: Ord,

impl<T> FusedIterator for rustmax::std::collections::btree_set::Union<'_, T>

where T: Ord,

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

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

impl<T> FusedIterator for rustmax::std::collections::vec_deque::Iter<'_, T>

impl<T> FusedIterator for rustmax::std::collections::vec_deque::IterMut<'_, T>

impl<T> FusedIterator for Empty<T>

impl<T> FusedIterator for Once<T>

impl<T> FusedIterator for rustmax::std::result::IntoIter<T>

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

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

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

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

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

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

impl<T> FusedIterator for rustmax::std::slice::Iter<'_, T>

impl<T> FusedIterator for rustmax::std::slice::IterMut<'_, T>

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

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

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

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

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

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

impl<T, A> FusedIterator for hashbrown::table::Drain<'_, T, A>

where A: Allocator,

impl<T, A> FusedIterator for hashbrown::table::IntoIter<T, A>

where A: Allocator,

impl<T, A> FusedIterator for rustmax::std::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 rustmax::std::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 rustmax::std::collections::btree_set::Difference<'_, T, A>

where T: Ord, A: Allocator + Clone,

impl<T, A> FusedIterator for rustmax::std::collections::btree_set::Intersection<'_, T, A>

where T: Ord, A: Allocator + Clone,

impl<T, A> FusedIterator for rustmax::std::collections::btree_set::IntoIter<T, A>

where A: Allocator + Clone,

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

where A: Allocator,

impl<T, A> FusedIterator for rustmax::std::collections::vec_deque::Drain<'_, T, A>

where A: Allocator,

impl<T, A> FusedIterator for rustmax::std::collections::vec_deque::IntoIter<T, A>

where A: Allocator,

impl<T, A> FusedIterator for rustmax::std::vec::Drain<'_, T, A>

where A: Allocator,

impl<T, A> FusedIterator for rustmax::std::vec::IntoIter<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 hashbrown::table::ExtractIf<'_, T, F, A>

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

impl<T, F, A> FusedIterator for rustmax::std::collections::btree_set::ExtractIf<'_, T, F, A>

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

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

where N: ArrayLength<T>,

impl<T, P> FusedIterator for rustmax::std::slice::RSplit<'_, T, P>

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

impl<T, P> FusedIterator for RSplitMut<'_, T, P>

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

impl<T, P> FusedIterator for rustmax::std::slice::Split<'_, T, P>

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

impl<T, P> FusedIterator for rustmax::std::slice::SplitInclusive<'_, T, P>

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

impl<T, P> FusedIterator for SplitInclusiveMut<'_, T, P>

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

impl<T, P> FusedIterator for SplitMut<'_, T, P>

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

impl<T, S1, S2> FusedIterator for indexmap::set::iter::SymmetricDifference<'_, T, S1, S2>

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

impl<T, S> FusedIterator for indexmap::set::iter::Difference<'_, T, S>

where T: Eq + Hash, S: BuildHasher,

impl<T, S> FusedIterator for indexmap::set::iter::Intersection<'_, T, S>

where T: Eq + Hash, S: BuildHasher,

impl<T, S> FusedIterator for indexmap::set::iter::Union<'_, T, S>

where T: Eq + Hash, S: BuildHasher,

impl<T, S> FusedIterator for rustmax::std::collections::hash_set::Difference<'_, T, S>

where T: Eq + Hash, S: BuildHasher,

impl<T, S> FusedIterator for rustmax::std::collections::hash_set::Intersection<'_, T, S>

where T: Eq + Hash, S: BuildHasher,

impl<T, S> FusedIterator for rustmax::std::collections::hash_set::SymmetricDifference<'_, T, S>

where T: Eq + Hash, S: BuildHasher,

impl<T, S> FusedIterator for rustmax::std::collections::hash_set::Union<'_, T, S>

where T: Eq + Hash, S: BuildHasher,

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

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

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

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

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

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

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

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

impl<T, U> FusedIterator for itertools::zip_longest::ZipLongest<T, U>

where T: Iterator, U: Iterator,

impl<T, U> FusedIterator for rustmax::itertools::ZipLongest<T, U>

where T: Iterator, U: Iterator,

impl<T, const N: usize> FusedIterator for rustmax::std::array::IntoIter<T, N>

impl<T, const N: usize> FusedIterator for rustmax::std::slice::ArrayChunks<'_, T, N>

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