调用在循环中使用“&mut self.0”的函数 （E0499）

问：

我正在寻找一种解决这种特定情况下缺乏 polonius 问题的方法。据我所知，其他答案似乎不适用。

我有两个结构，一个.前者是解耦的，但后者与前者高度耦合。 应该由任何 构造，并且应该由相同的构造。SourceBytes<S>SourceCharsSourceBytes<S>S: Iterator<Item = u8>SourceCharsS: Iterator<Item = u8>

以下是每个定义的样子：

#[derive(Clone, Debug)]
pub struct SourceBytes<S>
where
    S: Iterator<Item = u8>,
{
    iter: S,
    buffer: Vec<S::Item>,
}

#[derive(Clone, Debug)]
pub struct SourceChars<S>(S)
where
    S: Iterator<Item = u8>;

其目的是抽象化，以便可以缓冲每个项目，并且不可变地读取，而无需从迭代器中获取/弹出项目。它看起来像这样：SourceBytes<S>SS::Item

impl<S> Iterator for SourceBytes<S>
where
    S: Iterator<Item = u8>,
{
    type Item = S::Item;

    fn next(&mut self) -> Option<Self::Item> {
        self.buffer.pop().or_else(|| self.iter.next())
    }
}

这工作正常，缓冲区的处理方式如下：

impl<S> SourceBytes<S>
where
    S: Iterator<Item = u8>,
{
    // pub fn new<I>(iter: I) -> Self
    // where
    //     I: IntoIterator<Item = S::Item, IntoIter = S>,
    // {
    //     Self {
    //         iter: iter.into_iter(),
    //         buffer: Vec::new(),
    //     }
    // }

    fn buffer(&mut self, count: usize) -> Option<&[u8]> {
        if self.buffer.len() < count {
            self.buffer
                .extend(self.iter.by_ref().take(count - self.buffer.len()));
        }
        self.buffer.get(0..count)
    }
}

因此，每次调用时，项目都将从中获取并推送到 。每次调用时，它都会首先从 中获取，然后从后一个字段的类型中获取。SourceBytes<S>::bufferSbuffer<SourceBytes as Iterator>::nextself.bufferself.iterS

现在，目的是提供一个接口来读取字节（这是 ），直到它找到有效的 UTF-8 ，然后返回它：SourceChars<S>Iteratorself.0Schar

impl<S> Iterator for SourceChars<S>
where
    S: Iterator<Item = u8>,
{
    type Item = char;

    fn next(&mut self) -> Option<Self::Item> {
        let mut buf = [0; 4];
        // A single character can be at most 4 bytes.
        for (i, byte) in self.0.by_ref().take(4).enumerate() {
            buf[i] = byte;
            if let Ok(slice) = std::str::from_utf8(&buf[..=i]) {
                return slice.chars().next();
            }
        }
        None
    }
}

这也很好用。

现在，我还希望提供一个 for，以便可以依赖 提供的缓冲区（在这种情况下，它是 ）。implSourceChars<&mut SourceBytes<S>>SourceCharsself.0&mut SourceBytes<S>

impl<S> SourceChars<&mut SourceBytes<S>>
where
    S: Iterator<Item = u8>,
{
    fn buffer(&mut self, count: usize) -> Option<&str> {
        // let mut src = self.0.by_ref();
        for byte_count in 0.. {
            let Some(buf) = self.0.buffer(byte_count) else {
                return None;
            };
            if let Ok(slice) = std::str::from_utf8(buf) {
                if slice.chars().count() >= count {
                    return Some(slice);
                }
            }
        }
        unreachable!()
    }
}

这依赖于实际缓冲字节，而是充当包装器，将迭代器的解释从 bytes 更改为 s。SourceChars<&mut SourceBytes<S>>::bufferSourceBytes<S>::bufferSourceCharsSchar

问题在于不能多次可变地借用，并且在循环中，编译器似乎不会删除引用。self.0&mut self.0

我怎样才能在不遇到此编译器错误的情况下以依赖的方式实现它？SourceCharsSourceBytes::buffer

error[E0499]: cannot borrow `*self.0` as mutable more than once at a time
   --> src/parser/iter.rs:122:29
    |
119 |     fn buffer(&mut self, count: usize) -> Option<&str> {
    |               - let's call the lifetime of this reference `'1`
...
122 |             let Some(buf) = self.0.buffer(byte_count) else {
    |                             ^^^^^^ `*self.0` was mutably borrowed here in the previous iteration of the loop
...
127 |                     return Some(slice);
    |                            ----------- returning this value requires that `*self.0` is borrowed for `'1`