iterator - 从通用关联函数返回对值的引用的合适方法是什么？

Question

想象一个存储 3 个值的微型 map ，前两个用于已知键。我想为这张 map 实现一个迭代器，但我遇到了生命周期问题。从通用关联函数(下例中的 K::zero())返回对值的引用的合适方法是什么？ 仅供引用，我拥有该特征，所以我尝试将其更改为新的 RFC195关联的 const，这没有帮助。

我已将我的问题归结为以下代码:

extern crate num;

use num::*;

pub struct TinyMap<K: Num, V> {
    v0: Option<V>, // value for K::zero()
    v1: Option<V>, // value for K::one()
    k2: K,         // arbitrary K
    v2: Option<V>, // value for k2
}

pub struct Iter<'a, K: 'a + Num, V: 'a> {
    k0: K,
    v0: &'a Option<V>,
    v1: &'a Option<V>,
    k2: &'a K,
    v2: &'a Option<V>,
}

impl<K: Num, V> TinyMap<K, V> {
    pub fn iter(&self) -> Iter<K, V> {
        Iter {
            k0: K::zero(),
            v0: &self.v0,
            v1: &self.v1,
            k2: &self.k2,
            v2: &self.v2,
        }
    }
}

impl<'a, K: 'a + Num, V: 'a> Iterator for Iter<'a, K, V> {
    type Item = (&'a K, &'a V);

    fn next(&mut self) -> Option<(&'a K, &'a V)> {
        if (*self.v0).is_some() {
            // code removed that remembers we did this once.
            return Some((&self.k0, ((*self.v0).as_ref()).unwrap()));
        }
        // if (*self.v1).is_some() {
        //     code removed that remembers we did this once.
        //     return Some((&K::one(), &((*self.v1).unwrap())));
        // }
        None
    }
}

error[E0495]: cannot infer an appropriate lifetime for borrow expression due to conflicting requirements
  --> src/lib.rs:38:26
   |
38 |             return Some((&self.k0, ((*self.v0).as_ref()).unwrap()));
   |                          ^^^^^^^^
   |
note: first, the lifetime cannot outlive the anonymous lifetime #1 defined on the method body at 35:5...
  --> src/lib.rs:35:5
   |
35 | /     fn next(&mut self) -> Option<(&'a K, &'a V)> {
36 | |         if (*self.v0).is_some() {
37 | |             // code removed that remembers we did this once.
38 | |             return Some((&self.k0, ((*self.v0).as_ref()).unwrap()));
...  |
44 | |         None
45 | |     }
   | |_____^
note: ...so that reference does not outlive borrowed content
  --> src/lib.rs:38:26
   |
38 |             return Some((&self.k0, ((*self.v0).as_ref()).unwrap()));
   |                          ^^^^^^^^
note: but, the lifetime must be valid for the lifetime 'a as defined on the impl at 32:6...
  --> src/lib.rs:32:6
   |
32 | impl<'a, K: 'a + Num, V: 'a> Iterator for Iter<'a, K, V> {
   |      ^^
   = note: ...so that the expression is assignable:
           expected std::option::Option<(&'a K, &'a V)>
              found std::option::Option<(&K, &V)>

Answer 1

使用 Iterator 特性是不可能做到这一点的，因为 self 引用的生命周期(它在你的代码中被删除了，但可以像这样明确地写成):

type Item = (&'a K, &'a V);
fn next<'s>(&'s mut self) -> Self::Item;

因为 的 没有出现在函数的返回值中(也不能出现在那里，因为 Self::Item 不能使用类型参数函数)，输出不允许持有对迭代器的任何成员变量的引用。

这就是错误的机制，现在是为什么部分:

考虑一个包含对 self 成员的引用的函数，所有生命周期都设置正确:

struct SomeMember;
struct SomeObject {
    some_member: SomeMember,
}
impl SomeObject {
    fn some_function<'s>(&'s mut self) -> &'s SomeMember {
        &self.some_member
    }
}

与您尝试返回 &self.k 的方式相同，但没有任何其他事情发生，并且生命周期固定，因此它是允许的。但是，如果我随后尝试这样做:

fn main() {
    let mut some_object = SomeObject{some_member: SomeMember};
    let _item_1 = some_object.some_function();
    let _item_2 = some_object.some_function();
}

error[E0499]: cannot borrow `some_object` as mutable more than once at a time
  --> src/main.rs:15:23
   |
14 |         let _item_1 = some_object.some_function();
   |                       ----------- first mutable borrow occurs here
15 |         let _item_2 = some_object.some_function();
   |                       ^^^^^^^^^^^ second mutable borrow occurs here
16 |     }
   |     - first borrow ends here

不允许第二次调用，因为它借用了 some_object 两次，可变地，经典的 Rust 禁忌!但是，如果我试图用借用迭代器本身的 Item 类型实现一个迭代器，那么 Iterator::collect() 将是不可能的，因为它试图一次拉出多个项目!

所以，不，迭代器不能返回借用其内容的项目。这是迭代器特征契约的一个明确的、有意的部分。