相关疑难解决方法(0)

我遇到了一个简化为以下问题的问题:

struct MyIter {
    vec: Vec<i8>,
}

fn fill_with_useful_data(v: &mut Vec<i8>) {
    /* ... */
}

impl<'a> Iterator for MyIter {
    type Item = &'a [i8];

    fn next(&mut self) -> Option<&'a [i8]> {
        fill_with_useful_data(&mut self.vec);

        Some(&self.vec)
    }
}

fn main() {
    for slice in (MyIter { vec: Vec::new() }) {
        println!("{}", slice);
    }
}

这会生成错误:

error[E0207]: the lifetime parameter `'a` is not constrained by the impl trait, self type, or predicates
 --> src/main.rs:9:6
  |
9 | impl<'a> Iterator for MyIter …

这个问题是相关的，但是它更涵盖了为什么编译器在从 返回可变引用时无法推断安全生命周期的原因Iterator::next，我想我理解。

我的问题是：

在设计自己的迭代器以生成可变引用时，您可以采取哪些具体步骤？最终，我希望有一个尽可能简洁、分步、注释的示例，说明 aIterator及其next实现，当他们遇到这种情况时，我（和任何人）可以将其作为明确的参考。unsafe例子很好，我想它们可能是必要的！

注意：我知道这MutItems通常是推荐的示例，但是它的实现可能很难遵循，因为没有关于 1. 标记在那种情况下如何工作以及 2.iterator!宏扩展到什么以及它如何工作的任何文档。如果你用MutItems你的例子，你能澄清这些事情吗？

我想设计一个支持可变迭代器的玩具容器类,但是我无法整理迭代器的生命周期及其对容器的引用.

我试图创建一个最小的非编译示例:

struct Payload {
    value: i32,
}

struct Container {
    val: Payload,
}

struct IterMut<'a> {
    cont: &'a mut Container,
    cnt: i32,
}

impl<'a> Container {
    fn new() -> Container {
        Container { val: Payload { value: 42 } }
    }
    fn iter_mut(&'a mut self) -> IterMut<'a> {
        IterMut {
            cont: self,
            cnt: 10,
        }
    }
}

impl<'a> Iterator for IterMut<'a> {
    type Item = &'a mut Payload;

    fn next<'b>(&'b mut self) -> Option<Self::Item> {
        self.cnt -= 1;

        if …

尝试在安全的 Rust 中创建可变迭代器时，我遇到了生命周期问题。

这是我将问题简化为：

struct DataStruct<T> {
    inner: Box<[T]>,
}

pub struct IterMut<'a, T> {
    obj: &'a mut DataStruct<T>,
    cursor: usize,
}

impl<T> DataStruct<T> {
    fn iter_mut(&mut self) -> IterMut<T> {
        IterMut { obj: self, cursor: 0 }
    }
}

impl<'a, T> Iterator for IterMut<'a, T> {
    type Item = &'a mut T;

    fn next(&mut self) -> Option<Self::Item> {
        let i = f(self.cursor);
        self.cursor += 1;
        self.obj.inner.get_mut(i)
    }
}

fn f(i: usize) -> usize {
   // some permutation of i …

我想实现一个如下所示的自定义迭代器，但无法解决引用问题。

use itertools::Product;
use std::ops::Range;
struct Iter2DMut<'a, T: 'a> {
    data: &'a mut [T],
    shape: (usize, usize),
    idx_iter: Product<Range<usize>, Range<usize>>,
}

impl<'a, T: 'a> Iterator for Iter2DMut<'a, T> {
    type Item = &'a mut T;
    fn next(&mut self) -> Option<Self::Item> {
        if let Some((i, j)) = self.idx_iter.next() {
            Some(&mut self.data[i + self.shape.0 * j])
        } else {
            None
        }
    }
}

并收到以下错误消息。

use itertools::Product;
use std::ops::Range;
struct Iter2DMut<'a, T: 'a> {
    data: &'a mut [T],
    shape: (usize, usize),
    idx_iter: Product<Range<usize>, …