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.

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl FusedIterator for IpAddrRange

impl FusedIterator for IpSubnets

impl FusedIterator for NaiveDateDaysIterator

impl FusedIterator for NaiveDateWeeksIterator

impl FusedIterator for otter_nodejs_tests::inventory::core::ascii::EscapeDefault

impl FusedIterator for otter_nodejs_tests::inventory::core::char::EscapeDebug

impl FusedIterator for otter_nodejs_tests::inventory::core::char::EscapeDefault

impl FusedIterator for otter_nodejs_tests::inventory::core::char::EscapeUnicode

impl FusedIterator for ToLowercase

impl FusedIterator for ToTitlecase

impl FusedIterator for ToUppercase

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

impl FusedIterator for otter_nodejs_tests::otter_base::crates::serde_json::map::IntoIter

impl FusedIterator for otter_nodejs_tests::otter_base::crates::serde_json::map::IntoValues

impl FusedIterator for otter_nodejs_tests::regex::bytes::SetMatchesIntoIter

impl FusedIterator for otter_nodejs_tests::regex::SetMatchesIntoIter

impl FusedIterator for otter_nodejs_tests::str::Bytes<'_>

impl FusedIterator for otter_nodejs_tests::str::CharIndices<'_>

impl FusedIterator for Chars<'_>

impl FusedIterator for EncodeUtf16<'_>

impl FusedIterator for otter_nodejs_tests::str::Lines<'_>

impl FusedIterator for LinesAny<'_>

impl FusedIterator for SplitAsciiWhitespace<'_>

impl FusedIterator for SplitWhitespace<'_>

impl FusedIterator for otter_nodejs_tests::str::Utf8Chunks<'_>

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

impl FusedIterator for IntoChars

impl FusedIterator for Incoming<'_>

impl FusedIterator for IntoIncoming

impl FusedIterator for Ancestors<'_>

impl FusedIterator for Components<'_>

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

impl FusedIterator for AnsiCodeIterator<'_>

impl FusedIterator for Walk

impl FusedIterator for Ipv4AddrRange

impl FusedIterator for Ipv6AddrRange

impl FusedIterator for Ipv4Subnets

impl FusedIterator for Ipv6Subnets

impl FusedIterator for U32Digits<'_>

impl FusedIterator for U64Digits<'_>

impl FusedIterator for Utf8Sequences

impl FusedIterator for Utf8CharIndices<'_>

impl FusedIterator for ErrorReportingUtf8Chars<'_>

impl FusedIterator for Utf8Chars<'_>

impl FusedIterator for walkdir::IntoIter

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

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

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

impl<'a> FusedIterator for otter_nodejs_tests::otter_base::crates::serde_json::map::Iter<'a>

impl<'a> FusedIterator for otter_nodejs_tests::otter_base::crates::serde_json::map::IterMut<'a>

impl<'a> FusedIterator for otter_nodejs_tests::otter_base::crates::serde_json::map::Keys<'a>

impl<'a> FusedIterator for otter_nodejs_tests::otter_base::crates::serde_json::map::Values<'a>

impl<'a> FusedIterator for otter_nodejs_tests::otter_base::crates::serde_json::map::ValuesMut<'a>

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

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

impl<'a> FusedIterator for otter_nodejs_tests::str::EscapeDebug<'a>

impl<'a> FusedIterator for otter_nodejs_tests::str::EscapeDefault<'a>

impl<'a> FusedIterator for otter_nodejs_tests::str::EscapeUnicode<'a>

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, '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 otter_nodejs_tests::slotmap::basic::Drain<'a, K, V>

where K: Key,

impl<'a, K, V> FusedIterator for otter_nodejs_tests::slotmap::basic::Iter<'a, K, V>

where K: Key,

impl<'a, K, V> FusedIterator for otter_nodejs_tests::slotmap::basic::IterMut<'a, K, V>

where K: Key,

impl<'a, K, V> FusedIterator for otter_nodejs_tests::slotmap::basic::Keys<'a, K, V>

where K: Key,

impl<'a, K, V> FusedIterator for otter_nodejs_tests::slotmap::basic::Values<'a, K, V>

where K: Key,

impl<'a, K, V> FusedIterator for otter_nodejs_tests::slotmap::basic::ValuesMut<'a, K, V>

where K: Key,

impl<'a, K, V> FusedIterator for otter_nodejs_tests::slotmap::dense::Drain<'a, K, V>

where K: 'a + Key,

impl<'a, K, V> FusedIterator for otter_nodejs_tests::slotmap::dense::Iter<'a, K, V>

where K: 'a + Key,

impl<'a, K, V> FusedIterator for otter_nodejs_tests::slotmap::dense::IterMut<'a, K, V>

where K: 'a + Key,

impl<'a, K, V> FusedIterator for otter_nodejs_tests::slotmap::dense::Keys<'a, K, V>

where K: 'a + Key,

impl<'a, K, V> FusedIterator for otter_nodejs_tests::slotmap::dense::Values<'a, K, V>

where K: 'a + Key,

impl<'a, K, V> FusedIterator for otter_nodejs_tests::slotmap::dense::ValuesMut<'a, K, V>

where K: 'a + Key,

impl<'a, K, V> FusedIterator for otter_nodejs_tests::slotmap::hop::Drain<'a, K, V>

where K: Key,

impl<'a, K, V> FusedIterator for otter_nodejs_tests::slotmap::hop::Iter<'a, K, V>

where K: Key,

impl<'a, K, V> FusedIterator for otter_nodejs_tests::slotmap::hop::IterMut<'a, K, V>

where K: Key,

impl<'a, K, V> FusedIterator for otter_nodejs_tests::slotmap::hop::Keys<'a, K, V>

where K: Key,

impl<'a, K, V> FusedIterator for otter_nodejs_tests::slotmap::hop::Values<'a, K, V>

where K: Key,

impl<'a, K, V> FusedIterator for otter_nodejs_tests::slotmap::hop::ValuesMut<'a, K, V>

where K: Key,

impl<'a, K, V> FusedIterator for otter_nodejs_tests::slotmap::secondary::Drain<'a, K, V>

where K: Key,

impl<'a, K, V> FusedIterator for otter_nodejs_tests::slotmap::secondary::Iter<'a, K, V>

where K: Key,

impl<'a, K, V> FusedIterator for otter_nodejs_tests::slotmap::secondary::IterMut<'a, K, V>

where K: Key,

impl<'a, K, V> FusedIterator for otter_nodejs_tests::slotmap::secondary::Keys<'a, K, V>

where K: Key,

impl<'a, K, V> FusedIterator for otter_nodejs_tests::slotmap::secondary::Values<'a, K, V>

where K: Key,

impl<'a, K, V> FusedIterator for otter_nodejs_tests::slotmap::secondary::ValuesMut<'a, K, V>

where K: Key,

impl<'a, K, V> FusedIterator for otter_nodejs_tests::slotmap::sparse_secondary::Drain<'a, K, V>

where K: Key,

impl<'a, K, V> FusedIterator for otter_nodejs_tests::slotmap::sparse_secondary::Iter<'a, K, V>

where K: Key,

impl<'a, K, V> FusedIterator for otter_nodejs_tests::slotmap::sparse_secondary::IterMut<'a, K, V>

where K: Key,

impl<'a, K, V> FusedIterator for otter_nodejs_tests::slotmap::sparse_secondary::Keys<'a, K, V>

where K: Key,

impl<'a, K, V> FusedIterator for otter_nodejs_tests::slotmap::sparse_secondary::Values<'a, K, V>

where K: Key,

impl<'a, K, V> FusedIterator for otter_nodejs_tests::slotmap::sparse_secondary::ValuesMut<'a, K, V>

where K: Key,

impl<'a, K, V> FusedIterator for enum_map::iter::Iter<'a, K, V>

where K: EnumArray<V>,

impl<'a, K, V> FusedIterator for enum_map::iter::IterMut<'a, K, V>

where K: EnumArray<V>,

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 otter_nodejs_tests::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 otter_nodejs_tests::str::RSplit<'a, P>

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

impl<'a, P> FusedIterator for otter_nodejs_tests::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 otter_nodejs_tests::str::Split<'a, P>

where P: Pattern,

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

where P: Pattern,

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

where P: Pattern,

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

where P: Pattern,

impl<'a, T> FusedIterator for http::header::map::Drain<'a, T>

impl<'a, T> FusedIterator for http::header::map::Iter<'a, T>

impl<'a, T> FusedIterator for http::header::map::IterMut<'a, T>

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

impl<'a, T> FusedIterator for http::header::map::ValuesMut<'a, T>

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, 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 otter_nodejs_tests::inventory::core::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 otter_nodejs_tests::inventory::core::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<'a, V> FusedIterator for enum_map::iter::Values<'a, V>

where V: 'a,

impl<'a, V> FusedIterator for enum_map::iter::ValuesMut<'a, V>

where V: 'a,

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

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

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

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

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

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

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

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

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

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

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

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<'v, T, I> FusedIterator for otter_nodejs_tests::vecdeque_stableix::Iter<'v, T, I>

where I: Offset,

impl<'v, T, I> FusedIterator for otter_nodejs_tests::vecdeque_stableix::IterMut<'v, T, I>

where I: Offset,

impl<A> FusedIterator for otter_nodejs_tests::inventory::core::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 otter_nodejs_tests::inventory::core::option::IntoIter<A>

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

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

impl<A> FusedIterator for OptionFlatten<A>

where A: FusedIterator,

impl<A> FusedIterator for RangeFromIter<A>

where A: Step,

impl<A> FusedIterator for RangeInclusiveIter<A>

where A: Step,

impl<A> FusedIterator for RangeIter<A>

where A: Step,

impl<A> FusedIterator for otter_nodejs_tests::otter_base::crates::itertools::RepeatN<A>

where A: Clone,

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

where A: Array,

impl<A> FusedIterator for Repeat<A>

where A: Clone,

impl<A> FusedIterator for otter_nodejs_tests::iter::RepeatN<A>

where A: Clone,

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<EntryData> FusedIterator for dlv_list::Drain<'_, EntryData>

impl<EntryData> FusedIterator for Indices<'_, EntryData>

impl<EntryData> FusedIterator for dlv_list::IntoIter<EntryData>

impl<EntryData> FusedIterator for dlv_list::Iter<'_, EntryData>

impl<EntryData> FusedIterator for dlv_list::IterMut<'_, EntryData>

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 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 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> 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 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 IntersperseWith<I, ElemF>

where I: Iterator, ElemF: IntersperseElement<<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 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: FusedIterator, 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, 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: FusedIterator, J: FusedIterator<Item = <I as Iterator>::Item>, F: MergePredicate<<I 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 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 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 ArrayChunks<I, N>

where I: FusedIterator,

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

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

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

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

where A: Allocator,

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

where A: Allocator,

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

where A: Allocator + Clone,

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 + Clone,

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

where A: Allocator,

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

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

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

where A: Allocator + Clone, 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 otter_nodejs_tests::btree_map::Iter<'_, K, V>

impl<K, V> FusedIterator for otter_nodejs_tests::btree_map::IterMut<'_, K, V>

impl<K, V> FusedIterator for otter_nodejs_tests::btree_map::Keys<'_, K, V>

impl<K, V> FusedIterator for otter_nodejs_tests::btree_map::Range<'_, K, V>

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

impl<K, V> FusedIterator for otter_nodejs_tests::btree_map::Values<'_, K, V>

impl<K, V> FusedIterator for otter_nodejs_tests::btree_map::ValuesMut<'_, K, V>

impl<K, V> FusedIterator for otter_nodejs_tests::hash_map::Iter<'_, K, V>

impl<K, V> FusedIterator for otter_nodejs_tests::hash_map::IterMut<'_, K, V>

impl<K, V> FusedIterator for otter_nodejs_tests::hash_map::Keys<'_, K, V>

impl<K, V> FusedIterator for otter_nodejs_tests::hash_map::Values<'_, K, V>

impl<K, V> FusedIterator for otter_nodejs_tests::hash_map::ValuesMut<'_, K, V>

impl<K, V> FusedIterator for otter_nodejs_tests::slotmap::basic::IntoIter<K, V>

where K: Key,

impl<K, V> FusedIterator for otter_nodejs_tests::slotmap::dense::IntoIter<K, V>

where K: Key,

impl<K, V> FusedIterator for otter_nodejs_tests::slotmap::hop::IntoIter<K, V>

where K: Key,

impl<K, V> FusedIterator for otter_nodejs_tests::slotmap::secondary::IntoIter<K, V>

where K: Key,

impl<K, V> FusedIterator for otter_nodejs_tests::slotmap::sparse_secondary::IntoIter<K, V>

where K: Key,

impl<K, V> FusedIterator for enum_map::iter::IntoIter<K, V>

where K: EnumArray<V>,

impl<K, V> FusedIterator for enum_map::iter::IntoValues<K, V>

where K: EnumArray<V>,

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

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::IterMut<'_, K, V>

impl<K, V> FusedIterator for hashbrown::map::Keys<'_, 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::Values<'_, K, V>

impl<K, V> FusedIterator for hashbrown::map::ValuesMut<'_, 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 indexmap::map::Drain<'_, K, V>

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

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

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

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

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

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

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

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

impl<K, V, A> FusedIterator for otter_nodejs_tests::btree_map::IntoIter<K, V, A>

where A: Allocator + Clone,

impl<K, V, A> FusedIterator for otter_nodejs_tests::btree_map::IntoKeys<K, V, A>

where A: Allocator + Clone,

impl<K, V, A> FusedIterator for otter_nodejs_tests::btree_map::IntoValues<K, V, A>

where A: Allocator + Clone,

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

where A: Allocator,

impl<K, V, A> FusedIterator for otter_nodejs_tests::hash_map::IntoIter<K, V, A>

where A: Allocator,

impl<K, V, A> FusedIterator for otter_nodejs_tests::hash_map::IntoKeys<K, V, A>

where A: Allocator,

impl<K, V, A> FusedIterator for otter_nodejs_tests::hash_map::IntoValues<K, V, A>

where A: Allocator,

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

where A: Allocator + Clone,

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 + Clone,

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 + Clone,

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 + Clone,

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

where A: Allocator,

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

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

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 indexmap::map::iter::ExtractIf<'_, K, V, F>

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

impl<K, V, F, A> FusedIterator for otter_nodejs_tests::hash_map::ExtractIf<'_, K, V, F, A>

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

impl<K, V, R, F> FusedIterator for otter_nodejs_tests::btree_map::ExtractIf<'_, K, V, R, F>

where K: PartialOrd, R: RangeBounds<K>, 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 otter_nodejs_tests::btree_set::Iter<'_, T>

impl<T> FusedIterator for otter_nodejs_tests::btree_set::Range<'_, T>

impl<T> FusedIterator for otter_nodejs_tests::btree_set::SymmetricDifference<'_, T>

where T: Ord,

impl<T> FusedIterator for otter_nodejs_tests::btree_set::Union<'_, T>

where T: Ord,

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

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

impl<T> FusedIterator for otter_nodejs_tests::inventory::core::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 otter_nodejs_tests::inventory::core::slice::Iter<'_, T>

impl<T> FusedIterator for otter_nodejs_tests::inventory::core::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 alloc::collections::binary_heap::Iter<'_, T>

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

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

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

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

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

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

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

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

impl<T> FusedIterator for http::header::map::IntoIter<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 indexmap::set::Drain<'_, T>

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

impl<T> FusedIterator for indexmap::set::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 PermitIterator<'_, T>

impl<T> FusedIterator for Empty<T>

impl<T> FusedIterator for Once<T>

impl<T, A> FusedIterator for otter_nodejs_tests::btree_set::Difference<'_, T, A>

where T: Ord, A: Allocator + Clone,

impl<T, A> FusedIterator for otter_nodejs_tests::btree_set::Intersection<'_, T, A>

where T: Ord, A: Allocator + Clone,

impl<T, A> FusedIterator for otter_nodejs_tests::btree_set::IntoIter<T, A>

where A: Allocator + Clone,

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::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 RawDrain<'_, T, A>

where A: Allocator + Clone,

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

where A: Allocator + Clone,

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, F> FusedIterator for indexmap::set::iter::ExtractIf<'_, T, F>

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

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, I> FusedIterator for otter_nodejs_tests::vecdeque_stableix::IntoIter<T, I>

where I: Offset,

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

where N: ArrayLength<T>,

impl<T, P> FusedIterator for otter_nodejs_tests::inventory::core::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 otter_nodejs_tests::inventory::core::slice::Split<'_, T, P>

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

impl<T, P> FusedIterator for otter_nodejs_tests::inventory::core::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, R, F, A> FusedIterator for otter_nodejs_tests::btree_set::ExtractIf<'_, T, R, F, A>

where A: Allocator + Clone, T: PartialOrd, R: RangeBounds<T>, F: 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, S1, S2> FusedIterator for indexmap::set::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 indexmap::set::Difference<'_, T, S>

where T: Eq + Hash, S: BuildHasher,

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

where T: Eq + Hash, S: BuildHasher,

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

where T: Eq + Hash, S: BuildHasher,

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

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

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

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

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

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

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

where A: Allocator, 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 + Clone,

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 + Clone,

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 + Clone,

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 + Clone,

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 ZipLongest<T, U>

where T: Iterator, U: Iterator,

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

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