#
core/iter/adapters/
by_ref_sized.rs

    1use crate::num::NonZero;
    2use crate::ops::{NeverShortCircuit, Try};
    3
    4/// Like `Iterator::by_ref`, but requiring `Sized` so it can forward generics.
    5///
    6/// Ideally this will no longer be required, eventually, but as can be seen in
    7/// the benchmarks (as of Feb 2022 at least) `by_ref` can have performance cost.
    8#[unstable(feature = "std_internals", issue = "none")]
    9#[derive(Debug)]
    10pub struct ByRefSized<'a, I>(pub &'a mut I);
    11
    12// The following implementations use UFCS-style, rather than trusting autoderef,
    13// to avoid accidentally calling the `&mut Iterator` implementations.
    14
    15#[unstable(feature = "std_internals", issue = "none")]
    16impl<I: Iterator> Iterator for ByRefSized<'_, I> {
    17    type Item = I::Item;
    18
    19    #[inline]
    20    fn next(&mut self) -> Option<Self::Item> {
    21        I::next(self.0)
    22    }
    23
    24    #[inline]
    25    fn size_hint(&self) -> (usize, Option<usize>) {
    26        I::size_hint(self.0)
    27    }
    28
    29    #[inline]
    30    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>> {
    31        I::advance_by(self.0, n)
    32    }
    33
    34    #[inline]
    35    fn nth(&mut self, n: usize) -> Option<Self::Item> {
    36        I::nth(self.0, n)
    37    }
    38
    39    #[inline]
    40    fn fold<B, F>(self, init: B, f: F) -> B
    41    where
    42        F: FnMut(B, Self::Item) -> B,
    43    {
    44        // `fold` needs ownership, so this can't forward directly.
    45        I::try_fold(self.0, init, NeverShortCircuit::wrap_mut_2(f)).0
    46    }
    47
    48    #[inline]
    49    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
    50    where
    51        F: FnMut(B, Self::Item) -> R,
    52        R: Try<Output = B>,
    53    {
    54        I::try_fold(self.0, init, f)
    55    }
    56}
    57
    58#[unstable(feature = "std_internals", issue = "none")]
    59impl<I: DoubleEndedIterator> DoubleEndedIterator for ByRefSized<'_, I> {
    60    #[inline]
    61    fn next_back(&mut self) -> Option<Self::Item> {
    62        I::next_back(self.0)
    63    }
    64
    65    #[inline]
    66    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>> {
    67        I::advance_back_by(self.0, n)
    68    }
    69
    70    #[inline]
    71    fn nth_back(&mut self, n: usize) -> Option<Self::Item> {
    72        I::nth_back(self.0, n)
    73    }
    74
    75    #[inline]
    76    fn rfold<B, F>(self, init: B, f: F) -> B
    77    where
    78        F: FnMut(B, Self::Item) -> B,
    79    {
    80        // `rfold` needs ownership, so this can't forward directly.
    81        I::try_rfold(self.0, init, NeverShortCircuit::wrap_mut_2(f)).0
    82    }
    83
    84    #[inline]
    85    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
    86    where
    87        F: FnMut(B, Self::Item) -> R,
    88        R: Try<Output = B>,
    89    {
    90        I::try_rfold(self.0, init, f)
    91    }
    92}