Trait sp_std::iter::FusedIterator

1.26.0 · source ·
pub trait FusedIterator: Iterator { }
Expand description

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 Iter<'_>

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

impl<'a, L, R> FusedIterator for Iter<'a, L, R>

impl<'a, L, R> FusedIterator for LeftValues<'a, L, R>

impl<'a, L, R> FusedIterator for RightValues<'a, L, R>

impl<'a, L, R> FusedIterator for LeftRange<'a, L, R>

impl<'a, L, R> FusedIterator for RightRange<'a, L, R>

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

impl<'a, L, R> FusedIterator for Iter<'a, L, R>

impl<'a, L, R> FusedIterator for LeftValues<'a, L, R>

impl<'a, L, R> FusedIterator for RightValues<'a, L, R>

impl<A, O> FusedIterator for IntoIter<A, O>where
    A: BitViewSized,
    O: BitOrder,

impl<T, O> FusedIterator for IntoIter<T, O>where
    T: BitStore,
    O: BitOrder,

impl<T, O> FusedIterator for Domain<'_, Const, T, O>where
    T: BitStore,
    O: BitOrder,

impl<M, T, O> FusedIterator for BitPtrRange<M, T, O>where
    M: Mutability,
    T: BitStore,
    O: BitOrder,

impl<T, O> FusedIterator for Iter<'_, T, O>where
    T: BitStore,
    O: BitOrder,

impl<T, O> FusedIterator for IterMut<'_, T, O>where
    T: BitStore,
    O: BitOrder,

impl<T, O> FusedIterator for BitValIter<'_, T, O>where
    T: BitStore,
    O: BitOrder,

impl<T, O> FusedIterator for Windows<'_, 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 ChunksMut<'_, 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 RChunks<'_, 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 RChunksExact<'_, T, O>where
    T: BitStore,
    O: BitOrder,

impl<T, O> FusedIterator for RChunksExactMut<'_, T, O>where
    T: BitStore,
    O: BitOrder,

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 SplitMut<'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 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<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, 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> FusedIterator for IterOnes<'_, T, O>where
    T: BitStore,
    O: BitOrder,

impl<T, O> FusedIterator for IterZeros<'_, T, O>where
    T: BitStore,
    O: BitOrder,

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 ChunksMutNoAlias<'a, T, O>where
    T: 'a + BitStore,
    O: BitOrder,
    ChunksMut<'a, T, O>: FusedIterator,

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 RChunksMutNoAlias<'a, T, O>where
    T: 'a + BitStore,
    O: BitOrder,
    RChunksMut<'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, 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 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 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 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, 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<T, O> FusedIterator for Drain<'_, 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<'a> FusedIterator for Bytes<'a>

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

impl<'a> FusedIterator for CharIndices<'a>

impl<'a> FusedIterator for Utf8Chunks<'a>

impl<'a> FusedIterator for ChunkIter<'a>

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

impl<T> FusedIterator for IntoIter<T>

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

impl<L, R> FusedIterator for Either<L, R>where
    L: FusedIterator,
    R: FusedIterator<Item = L::Item>,

impl<T: BitFlag> FusedIterator for Iter<T>

impl<T, N> FusedIterator for GenericArrayIter<T, N>where
    N: ArrayLength<T>,

impl<T> FusedIterator for RawIter<T>

impl<T, A: Allocator + Clone> FusedIterator for RawIntoIter<T, A>

impl<T, A: Allocator + Clone> FusedIterator for RawDrain<'_, T, A>

impl<K, V, A: Allocator + Clone> FusedIterator for IntoKeys<K, V, A>

impl<K, V, A: Allocator + Clone> FusedIterator for IntoValues<K, V, A>

impl<K, V, F> FusedIterator for DrainFilter<'_, K, V, F>where
    F: FnMut(&K, &mut V) -> bool,

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

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

impl<K, V, A: Allocator + Clone> FusedIterator for IntoIter<K, V, A>

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

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

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

impl<K, V, A: Allocator + Clone> FusedIterator for Drain<'_, K, V, A>

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

impl<K, A: Allocator + Clone> FusedIterator for IntoIter<K, A>

impl<K, A: Allocator + Clone> FusedIterator for Drain<'_, K, A>

impl<K, F, A: Allocator + Clone> FusedIterator for DrainFilter<'_, K, F, A>where
    F: FnMut(&K) -> bool,

impl<T, S, A> FusedIterator for Intersection<'_, T, S, A>where
    T: Eq + Hash,
    S: BuildHasher,
    A: Allocator + Clone,

impl<T, S, A> FusedIterator for Difference<'_, T, S, A>where
    T: Eq + Hash,
    S: BuildHasher,
    A: Allocator + Clone,

impl<T, S, A> FusedIterator for SymmetricDifference<'_, T, S, A>where
    T: Eq + Hash,
    S: BuildHasher,
    A: Allocator + Clone,

impl<T, S, A> FusedIterator for Union<'_, T, S, A>where
    T: Eq + Hash,
    S: BuildHasher,
    A: Allocator + Clone,

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

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

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

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

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

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

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

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

impl<T> FusedIterator for IntoIter<T>

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

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

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

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

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

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

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

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

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

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

impl<T> FusedIterator for IntoIter<T>

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

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

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, S1, S2> FusedIterator for SymmetricDifference<'_, T, S1, S2>where
    T: Eq + Hash,
    S1: BuildHasher,
    S2: BuildHasher,

impl<T, S> FusedIterator for Union<'_, T, S>where
    T: Eq + Hash,
    S: BuildHasher,

impl<I, J> FusedIterator for Interleave<I, J>where
    I: Iterator,
    J: Iterator<Item = I::Item>,

impl<I, J> FusedIterator for InterleaveShortest<I, J>where
    I: FusedIterator,
    J: FusedIterator<Item = I::Item>,

impl<I, J> FusedIterator for Product<I, J>where
    I: FusedIterator,
    J: Clone + FusedIterator,
    I::Item: Clone,

impl<I, J, F> FusedIterator for MergeBy<I, J, F>where
    I: FusedIterator,
    J: FusedIterator<Item = I::Item>,
    F: MergePredicate<I::Item>,

impl<I, T> FusedIterator for TupleCombinations<I, T>where
    I: FusedIterator,
    T: HasCombination<I>,

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, F> FusedIterator for Positions<I, F>where
    I: FusedIterator,
    F: FnMut(I::Item) -> bool,

impl<I, F> FusedIterator for Update<I, F>where
    I: FusedIterator,
    F: FnMut(&mut I::Item),

impl<I> FusedIterator for Combinations<I>where
    I: Iterator,
    I::Item: Clone,

impl<I> FusedIterator for CombinationsWithReplacement<I>where
    I: Iterator,
    I::Item: Clone,

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

impl<I, ElemF> FusedIterator for IntersperseWith<I, ElemF>where
    I: Iterator,
    ElemF: IntersperseElement<I::Item>,

impl<I, F> FusedIterator for KMergeBy<I, F>where
    I: Iterator,
    F: KMergePredicate<I::Item>,

impl<I, F> FusedIterator for PadUsing<I, F>where
    I: FusedIterator,
    F: FnMut(usize) -> I::Item,

impl<I> FusedIterator for Powerset<I>where
    I: Iterator,
    I::Item: Clone,

impl<A, I> FusedIterator for RcIter<I>where
    I: FusedIterator<Item = A>,

impl<A> FusedIterator for RepeatN<A>where
    A: Clone,

impl<I, T> FusedIterator for TupleWindows<I, T>where
    I: FusedIterator<Item = T::Item>,
    T: HomogeneousTuple + Clone,
    T::Item: Clone,

impl<I, V, F> FusedIterator for UniqueBy<I, V, F>where
    I: FusedIterator,
    V: Eq + Hash,
    F: FnMut(&I::Item) -> V,

impl<I> FusedIterator for Unique<I>where
    I: FusedIterator,
    I::Item: Eq + Hash + Clone,

impl<T, U> FusedIterator for ZipLongest<T, U>where
    T: Iterator,
    U: Iterator,

impl<'a> FusedIterator for ArrayIter<'a>

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

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

impl<K, V> FusedIterator for IntoIter<K, V>where
    K: Hash + Eq,

impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + Storage<T, R, C>> FusedIterator for MatrixIter<'a, T, R, C, S>

impl<'a, T: Scalar, R: Dim, C: Dim, S: 'a + StorageMut<T, R, C>> FusedIterator for MatrixIterMut<'a, T, R, C, S>

impl<P> FusedIterator for Split<'_, P>where
    P: Pattern,

impl<D, R, T> FusedIterator for DistIter<D, R, T>where
    D: Distribution<T>,
    R: Rng,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<'de, R, T> FusedIterator for StreamDeserializer<'de, R, T>where
    R: Read<'de> + Fused,
    T: Deserialize<'de>,

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

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

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

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

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

impl<T> FusedIterator for IntoIter<T>

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

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

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

impl<'a, T> FusedIterator for LinearGroup<'a, T>where
    T: PartialEq + 'a,

impl<'a, T> FusedIterator for LinearGroupMut<'a, T>where
    T: PartialEq + 'a,

impl<'a, T: 'a, P> FusedIterator for LinearGroupBy<'a, T, P>where
    P: FnMut(&T, &T) -> bool,

impl<'a, T: 'a, P> FusedIterator for LinearGroupByMut<'a, T, P>where
    P: FnMut(&T, &T) -> bool,

impl<'a, T: 'a, F, K> FusedIterator for LinearGroupByKey<'a, T, F>where
    F: FnMut(&T) -> K,
    K: PartialEq,

impl<'a, T: 'a, F, K> FusedIterator for LinearGroupByKeyMut<'a, T, F>where
    F: FnMut(&T) -> K,
    K: PartialEq,

impl<'a, T> FusedIterator for BinaryGroup<'a, T>where
    T: PartialEq + 'a,

impl<'a, T> FusedIterator for BinaryGroupMut<'a, T>where
    T: PartialEq + 'a,

impl<'a, T: 'a, P> FusedIterator for BinaryGroupBy<'a, T, P>where
    P: FnMut(&T, &T) -> bool,

impl<'a, T: 'a, P> FusedIterator for BinaryGroupByMut<'a, T, P>where
    P: FnMut(&T, &T) -> bool,

impl<'a, T: 'a, F, K> FusedIterator for BinaryGroupByKey<'a, T, F>where
    F: FnMut(&T) -> K,
    K: PartialEq,

impl<'a, T: 'a, F, K> FusedIterator for BinaryGroupByKeyMut<'a, T, F>where
    F: FnMut(&T) -> K,
    K: PartialEq,

impl<'a, T> FusedIterator for ExponentialGroup<'a, T>where
    T: PartialEq + 'a,

impl<'a, T> FusedIterator for ExponentialGroupMut<'a, T>where
    T: PartialEq + 'a,

impl<'a, T: 'a, P> FusedIterator for ExponentialGroupBy<'a, T, P>where
    P: FnMut(&T, &T) -> bool,

impl<'a, T: 'a, P> FusedIterator for ExponentialGroupByMut<'a, T, P>where
    P: FnMut(&T, &T) -> bool,

impl<'a, T: 'a, F, K> FusedIterator for ExponentialGroupByKey<'a, T, F>where
    F: FnMut(&T) -> K,
    K: PartialEq,

impl<'a, T: 'a, F, K> FusedIterator for ExponentialGroupByKeyMut<'a, T, F>where
    F: FnMut(&T) -> K,
    K: PartialEq,

impl<'a> FusedIterator for LinearStrGroup<'a>

impl<'a, P> FusedIterator for LinearStrGroupBy<'a, P>where
    P: FnMut(char, char) -> bool,

impl<'a, P> FusedIterator for LinearStrGroupByMut<'a, P>where
    P: FnMut(char, char) -> bool,

impl<'a, F, K> FusedIterator for LinearStrGroupByKey<'a, F>where
    F: FnMut(char) -> K,
    K: PartialEq,

impl<'a, F, K> FusedIterator for LinearStrGroupByKeyMut<'a, F>where
    F: FnMut(char) -> K,
    K: PartialEq,

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

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

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

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

impl<'a, K: Key, V> FusedIterator for ValuesMut<'a, K, V>

impl<'a, K: Key, V> FusedIterator for Drain<'a, K, V>

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

impl<'a, K: 'a + Key, V> FusedIterator for Iter<'a, K, V>

impl<'a, K: 'a + Key, V> FusedIterator for IterMut<'a, K, V>

impl<'a, K: 'a + Key, V> FusedIterator for Keys<'a, K, V>

impl<'a, K: 'a + Key, V> FusedIterator for Values<'a, K, V>

impl<'a, K: 'a + Key, V> FusedIterator for ValuesMut<'a, K, V>

impl<'a, K: 'a + Key, V> FusedIterator for Drain<'a, K, V>

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

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

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

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

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

impl<'a, K: Key, V> FusedIterator for ValuesMut<'a, K, V>

impl<'a, K: Key, V> FusedIterator for Drain<'a, K, V>

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

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

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

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

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

impl<'a, K: Key, V> FusedIterator for ValuesMut<'a, K, V>

impl<'a, K: Key, V> FusedIterator for Drain<'a, K, V>

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

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

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

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

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

impl<'a, K: Key, V> FusedIterator for ValuesMut<'a, K, V>

impl<'a, K: Key, V> FusedIterator for Drain<'a, K, V>

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

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

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

impl<T: Send + Sync> FusedIterator for Iter<'_, T>

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

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

impl<'p, A, I> FusedIterator for ArrayVecSplice<'p, A, I>where
    A: Array,
    I: Iterator<Item = A::Item>,

impl<'a, T: 'a + Default> FusedIterator for ArrayVecDrain<'a, T>

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

impl<'p, A, I> FusedIterator for TinyVecSplice<'p, A, I>where
    A: Array,
    I: Iterator<Item = A::Item>,

impl<I> FusedIterator for Bidi<I>where
    I: DoubleEndedIterator + FusedIterator,